zopefoundation__DateTime-62

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

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "from time import gmtime\nfrom time import localtime\nfrom time import time\nfrom time import timezone\nfrom time import tzname\n\nfrom zope.interface import implementer\n\nfrom .interfaces import DateError\nfrom .interfaces import DateTimeError\nfrom .interfaces import IDateTime\nfrom .interfaces import SyntaxError\nfrom .interfaces import TimeError\nfrom .pytz_support import PytzCache\n\n\nbasestring = str\nlong = int\nexplicit_unicode_type = type(None)\n\ndefault_datefmt = None\n\n\ndef getDefaultDateFormat():\n    global default_datefmt\n    if default_datefmt is None:\n        try:\n            from App.config import getConfiguration\n            default_datefmt = getConfiguration().datetime_format\n            return default_datefmt\n        except Exception:\n            return 'us'\n    else:\n        return default_datefmt\n\n\n# To control rounding errors, we round system time to the nearest\n# microsecond.  Then delicate calculations can rely on the fact that the\n# maximum precision that needs to be preserved is known.\n_system_time = time\n",
  "start_line": 20,
  "end_line": 60,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "             '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:\n    (?P<signal>[-+])                #  one plus or one minus as signal\n    (?P<hour_off>\\d                 #  one digit for hour offset...\n     (?:\\d(?!\\d$)                   #  ...or two, if not the last two digits\n    )?)                             #  second hour offset digit is optional\n    (?::?                           #  one optional colon\n     (?P<min_off>\\d\\d)              #  two digits minute offset\n    )?                              #  after hour offset is optional\n   )?                               # timezone is optional\n  )?                                # time is optional\n  (?P<garbage>.*)                   # store the extra garbage\n''', re.VERBOSE).match\n\n\ndef _findLocalTimeZoneName(isDST):\n    if not daylight:\n        # Daylight savings does not occur in this time zone.\n        isDST = 0\n    try:\n        # Get the name of the current time zone depending\n        # on DST.\n        _localzone = PytzCache._zmap[tzname[isDST].lower()]\n    except BaseException:\n        try:\n            # Generate a GMT-offset zone name.\n            if isDST:\n                localzone = altzone\n            else:\n                localzone = timezone\n            offset = (-localzone / 3600.0)\n            majorOffset = int(offset)\n            if majorOffset != 0:\n                minorOffset = abs(int((offset % majorOffset) * 60.0))\n            else:\n                minorOffset = 0\n            m = majorOffset >= 0 and '+' or ''\n            lz = '%s%0.02d%0.02d' % (m, majorOffset, minorOffset)\n            _localzone = PytzCache._zmap[('GMT%s' % lz).lower()]\n        except BaseException:\n            _localzone = ''\n    return _localzone\n\n\n_localzone0 = _findLocalTimeZoneName(0)\n_localzone1 = _findLocalTimeZoneName(1)\n_multipleZones = (_localzone0 != _localzone1)\n\n# Some utility functions for calculating dates:\n\n\ndef _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):",
  "start_line": 100,
  "end_line": 249,
  "total_lines": 1946,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "    # 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\ndef _julianday(yr, mo, dy):\n    y, m, d = long(yr), long(mo), long(dy)\n    if m > 12:\n        y = y + m // 12\n        m = m % 12\n    elif m < 1:\n        m = -m\n        y = y - m // 12 - 1\n        m = 12 - m % 12\n    if y > 0:\n        yr_correct = 0\n    else:\n        yr_correct = 3\n    if m < 3:\n        y, m = y - 1, m + 12\n    if y * 10000 + m * 100 + d > 15821014:\n        b = 2 - y // 100 + y // 400\n    else:\n        b = 0\n    return ((1461 * y - yr_correct) // 4 +\n            306001 * (m + 1) // 10000 + d + 1720994 + b)\n\n\ndef _calendarday(j):\n    j = long(j)\n    if (j < 2299160):\n        b = j + 1525\n    else:\n        a = (4 * j - 7468861) // 146097\n        b = j + 1526 + a - a // 4\n    c = (20 * b - 2442) // 7305\n    d = 1461 * c // 4\n    e = 10000 * (b - d) // 306001\n    dy = int(b - d - 306001 * e // 10000)\n    mo = (e < 14) and int(e - 1) or int(e - 13)\n    yr = (mo > 2) and (c - 4716) or (c - 4715)\n    return (int(yr), int(mo), int(dy))\n\n\ndef _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",
  "start_line": 250,
  "end_line": 399,
  "total_lines": 1946,
  "is_truncated": true
}

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

{
  "status": "ok",
  "stdout": "Original: 2198556426235027\nFloat:    2198556426.235027\nRecovered:2198556426235027\nDiff:     0\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Original: 2198556426235027\nFloat:    2198556426.235027\nRecovered:2198556426235026\nDiff:     1\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "            New in Zope 2.4:\n            The DateTime constructor automatically detects and handles\n            ISO8601 compliant dates (YYYY-MM-DDThh:ss:mmTZD).\n\n            New in Zope 2.9.6:\n            The existing ISO8601 parser was extended to support almost\n            the whole ISO8601 specification. New formats includes:\n\n            <pre>\n            y = DateTime('1993-045')\n            # returns the 45th day from 1993, which is 14th February\n\n            w = DateTime('1993-W06-7')\n            # returns the 7th day from the 6th week from 1993, which\n            # is also 14th February\n            </pre>\n\n            See http://en.wikipedia.org/wiki/ISO_8601 for full specs.\n\n            Note that the Zope DateTime parser assumes timezone naive ISO\n            strings to be in UTC rather than local time as specified.\n\n          - If the DateTime function is invoked with a single numeric\n            argument, the number is assumed to be a floating point value\n            such as that returned by time.time().\n\n            A DateTime object is returned that represents the GMT value\n            of the time.time() float represented in the local machine's\n            timezone.\n\n          - If the DateTime function is invoked with a single argument\n            that is a DateTime instance, a copy of the passed object will\n            be created.\n\n          - New in 2.11:\n            The DateTime function may now be invoked with a single argument\n            that is a datetime.datetime instance. DateTimes may be converted\n            back to datetime.datetime objects with asdatetime().\n            DateTime instances may be converted to a timezone naive\n            datetime.datetime in UTC with utcdatetime().\n\n          - If the function is invoked with two numeric arguments, then\n            the first is taken to be an integer year and the second\n            argument is taken to be an offset in days from the beginning\n            of the year, in the context of the local machine timezone.\n\n            The date-time value returned is the given offset number of\n            days from the beginning of the given year, represented in\n            the timezone of the local machine. The offset may be positive\n            or negative.\n\n            Two-digit years are assumed to be in the twentieth\n            century.\n\n          - If the function is invoked with two arguments, the first\n            a float representing a number of seconds past the epoch\n            in gmt (such as those returned by time.time()) and the\n            second a string naming a recognized timezone, a DateTime\n            with a value of that gmt time will be returned, represented\n            in the given timezone.\n\n            <pre>\n            import time\n            t = time.time()\n\n            now_east = DateTime(t,'US/Eastern')\n            # Time t represented as US/Eastern\n\n            now_west = DateTime(t,'US/Pacific')\n            # Time t represented as US/Pacific\n\n            # now_east == now_west\n            # only their representations are different\n            </pre>\n\n          - If the function is invoked with three or more numeric\n            arguments, then the first is taken to be an integer\n            year, the second is taken to be an integer month, and\n            the third is taken to be an integer day. If the\n            combination of values is not valid, then a\n            DateError is raised. Two-digit years are assumed\n            to be in the twentieth century. The fourth, fifth, and\n            sixth arguments specify a time in hours, minutes, and\n            seconds; hours and minutes should be positive integers\n            and seconds is a positive floating point value, all of\n            these default to zero if not given. An optional string may\n            be given as the final argument to indicate timezone (the\n            effect of this is as if you had taken the value of time.time()\n            at that time on a machine in the specified timezone).\n\n            New in Zope 2.7:\n            A new keyword parameter \"datefmt\" can be passed to the\n            constructor. If set to \"international\", the constructor\n            is forced to treat ambiguous dates as \"days before month\n            before year\". This useful if you need to parse non-US\n            dates in a reliable way\n\n        In any case that a floating point number of seconds is given\n        or derived, it's rounded to the nearest millisecond.\n\n        If a string argument passed to the DateTime constructor cannot be\n        parsed, it will raise DateTime.SyntaxError. Invalid date components\n        will raise a DateError, while invalid time or timezone components\n        will raise a DateTimeError.\n\n        The module function Timezones() will return a list of the (common)\n        timezones recognized by the DateTime module. Recognition of\n        timezone names is case-insensitive.\n        \"\"\"\n\n        datefmt = kw.get('datefmt', getDefaultDateFormat())\n        d = t = s = None\n        ac = len(args)\n        microsecs = None\n\n        if ac == 10:\n            # Internal format called only by DateTime\n            yr, mo, dy, hr, mn, sc, tz, t, d, s = args\n        elif ac == 11:\n            # Internal format that includes milliseconds (from the epoch)\n            yr, mo, dy, hr, mn, sc, tz, t, d, s, millisecs = args\n            microsecs = millisecs * 1000\n\n        elif ac == 12:\n            # Internal format that includes microseconds (from the epoch) and a\n            # flag indicating whether this was constructed in a timezone naive\n            # manner\n            yr, mo, dy, hr, mn, sc, tz, t, d, s, microsecs, tznaive = args\n            if tznaive is not None:  # preserve this information\n                self._timezone_naive = tznaive\n\n        elif not args or (ac and args[0] is None):\n            # Current time, to be displayed in local timezone\n            t = time()\n            lt = safelocaltime(t)\n            tz = self.localZone(lt)\n            ms = (t - math.floor(t))\n            s, d = _calcSD(t)\n            yr, mo, dy, hr, mn, sc = lt[:6]\n            sc = sc + ms\n            self._timezone_naive = False\n\n        elif ac == 1:\n            arg = args[0]\n\n            if arg == '':\n                raise SyntaxError(arg)\n\n            if isinstance(arg, DateTime):\n                \"\"\"Construct a new DateTime instance from a given",
  "start_line": 550,
  "end_line": 699,
  "total_lines": 1946,
  "is_truncated": true
}

{
  "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)",
  "start_line": 700,
  "end_line": 800,
  "total_lines": 1946,
  "is_truncated": false
}

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

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "class DateTime:\n    \"\"\"DateTime objects represent instants in time and provide\n       interfaces for controlling its representation without\n       affecting the absolute value of the object.\n\n       DateTime objects may be created from a wide variety of string\n       or numeric data, or may be computed from other DateTime objects.\n       DateTimes support the ability to convert their representations\n       to many major timezones, as well as the ability to create a\n       DateTime object in the context of a given timezone.\n\n       DateTime objects provide partial numerical behavior:\n\n          - Two date-time objects can be subtracted to obtain a time,\n            in days between the two.\n\n          - A date-time object and a positive or negative number may\n            be added to obtain a new date-time object that is the given\n            number of days later than the input date-time object.\n\n          - A positive or negative number and a date-time object may\n            be added to obtain a new date-time object that is the given\n            number of days later than the input date-time object.\n\n          - A positive or negative number may be subtracted from a\n            date-time object to obtain a new date-time object that is\n            the given number of days earlier than the input date-time\n            object.\n\n        DateTime objects may be converted to integer, long, or float\n        numbers of days since January 1, 1901, using the standard int,\n        long, and float functions (Compatibility Note: int, long and\n        float return the number of days since 1901 in GMT rather than\n        local machine timezone). DateTime objects also provide access\n        to their value in a float format usable with the Python time\n        module, provided that the value of the object falls in the\n        range of the epoch-based time module, and as a datetime.datetime\n        object.\n\n        A DateTime object should be considered immutable; all conversion\n        and numeric operations return a new DateTime object rather than\n        modify the current object.\"\"\"\n\n    # For security machinery:\n    __roles__ = None\n    __allow_access_to_unprotected_subobjects__ = 1\n\n    # Limit the amount of instance attributes\n    __slots__ = (\n        '_timezone_naive',\n        '_tz',\n        '_dayoffset',\n        '_year',\n        '_month',\n        '_day',\n        '_hour',\n        '_minute',\n        '_second',\n        '_nearsec',\n        '_d',\n        '_micros',\n        'time',\n    )\n\n    def __init__(self, *args, **kw):\n        \"\"\"Return a new date-time object\"\"\"\n        try:\n            return self._parse_args(*args, **kw)\n        except (DateError, TimeError, DateTimeError):\n            raise\n        except Exception:\n            raise SyntaxError('Unable to parse {}, {}'.format(args, kw))\n\n    def __getstate__(self):\n        # We store a float of _micros, instead of the _micros long, as we most\n        # often don't have any sub-second resolution and can save those bytes",
  "start_line": 375,
  "end_line": 450,
  "total_lines": 1946,
  "is_truncated": false
}

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

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

{
  "status": "ok",
  "filepath": "src/DateTime/DateTime.py",
  "content": "    def _parse_args(self, *args, **kw):\n        \"\"\"Return a new date-time object.\n\n        A DateTime object always maintains its value as an absolute\n        UTC time, and is represented in the context of some timezone\n        based on the arguments used to create the object. A DateTime\n        object's methods return values based on the timezone context.\n\n        Note that in all cases the local machine timezone is used for\n        representation if no timezone is specified.\n\n        DateTimes may be created with zero to seven arguments.\n\n          - If the function is called with no arguments or with None,\n            then the current date/time is returned, represented in the\n            timezone of the local machine.\n\n          - If the function is invoked with a single string argument\n            which is a recognized timezone name, an object representing\n            the current time is returned, represented in the specified\n            timezone.\n\n          - If the function is invoked with a single string argument\n            representing a valid date/time, an object representing\n            that date/time will be returned.\n\n            As a general rule, any date-time representation that is\n            recognized and unambiguous to a resident of North America\n            is acceptable. The reason for this qualification is that\n            in North America, a date like: 2/1/1994 is interpreted\n            as February 1, 1994, while in some parts of the world,\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": 470,
  "end_line": 600,
  "total_lines": 1946,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "371:        return self.dt.strftime(self.format)\n442:            return self._parse_args(*args, **kw)\n1131:        return self._micros / 1000000.0\n1145:            return self.__class__(yr, mo, dy, hr, mn, sc, tz, t,\n1152:                return self\n1159:            return self.__class__(yr, mo, dy, hr, mn, sc, tz, t,\n1227:        return self.__class__(\n1235:        return self.__class__(\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\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\n1398:        return self._tz\n1406:        return self._year\n1410:        return self._month\n1418:        return self._fmon\n1426:        return self._amon\n1430:        return self._amon\n1438:        return self._pmon\n1442:        return self._pmon\n1446:        return self._day\n1454:        return self._fday\n1458:        return self._fday\n1466:        return self._aday\n1474:        return self._pday\n1478:        return self._pday\n1482:        return self._dayoffset\n1486:        return self._dayoffset + 1\n1497:        return self._pmhour\n1501:        return self._hour\n1512:        return self._pm\n1516:        return self._hour\n1520:        return self._minute\n1524:        return self._second\n1528:        return self._micros // 1000\n1532:        return self._micros\n1542:            return self._timezone_naive\n1756:        return self.__class__(yr, mo, dy, hr, mn, sc, self._tz,\n1769:            return self.__add__(-(other))\n1797:            return self.strftime(fmt)\n1816:        return self.micros() / 1000000.0\n1820:        return self._micros / 1000000.0\n1825:        return self._parse_iso8601_preserving_tznaive(s)[:7]\n1829:            return self.__parse_iso8601(s)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "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)\n        tz = self.localZone(ltm)\n        return tz\n\n    def _parse(self, st, datefmt=getDefaultDateFormat()):\n        # Parse date-time components from a string\n        month = year = tz = tm = None\n        ValidZones = _TZINFO._zidx\n        TimeModifiers = ['am', 'pm']\n\n        # Find timezone first, since it should always be the last\n        # element, and may contain a slash, confusing the parser.\n        st = st.strip()\n        sp = st.split()\n        tz = sp[-1]\n        if tz and (tz.lower() in ValidZones):\n            self._timezone_naive = False\n            st = ' '.join(sp[:-1])\n        else:\n            self._timezone_naive = True\n            tz = None  # Decide later, since the default time zone\n        # could depend on the date.\n\n        ints = []\n        i = 0\n        len_st = len(st)\n        while i < len_st:\n            while i < len_st and st[i] in SPACE_CHARS:\n                i += 1\n            if i < len_st and st[i] in DELIMITERS:\n                d = st[i]\n                i += 1\n            else:\n                d = ''\n            while i < len_st and st[i] in SPACE_CHARS:\n                i += 1\n\n            # The float pattern needs to look back 1 character, because it\n            # actually looks for a preceding colon like ':33.33'. This is\n            # needed to avoid accidentally matching the date part of a\n            # dot-separated date string such as '1999.12.31'.\n            if i > 0:\n                b = i - 1\n            else:\n                b = i\n\n            ts_results = FLT_PATTERN.match(st, b)\n            if ts_results:\n                s = ts_results.group(1)\n                i = i + len(s)",
  "start_line": 800,
  "end_line": 949,
  "total_lines": 1946,
  "is_truncated": true
}