Python DateTime.DateTime类代码示例

        def _calculate_two_weeks():
            two_weeks = [[None] * 7, [None] * 7]

            brains = portal_catalog.searchResults(
                    {'path' : path,
                     'portal_type': 'Milestone',
                     'end': {"query": [today, today+14], "range": "minmax"},
                    },
                    )

            _upcoming = {}
            for b in brains:
                end = b.end
                end = DateTime(end.year(), end.month(), end.day())

                _upcoming.setdefault(end, []).append(b)

            day = today
            for i in range(2):
                for j in range(7):
                    two_weeks[i][j] = {}
                    two_weeks[i][j]["day"] = day.day()
                    if _upcoming.has_key(day):
                        two_weeks[i][j]["its"] = _upcoming[day]
                    day += 1
            nextday = today+1
            two_weeks[0][0]["day"] = "TODAY"
            two_weeks[0][0]["is_today"] = True
            two_weeks[0][1]["day"] = "%s %d" % (nextday.aMonth(), nextday.day())

            return two_weeks

 def testEDTTimezone(self):
     # should be able to parse EDT timezones:  see lp:599856.
     dt = DateTime("Mon, 28 Jun 2010 10:12:25 EDT")
     self.assertEqual(dt.Day(), 'Monday')
     self.assertEqual(dt.day(), 28)
     self.assertEqual(dt.Month(), 'June')
     self.assertEqual(dt.timezone(), 'GMT-4')

 def test_12_Every5Minutes(self, quiet=0, run=run_all_test):
   if not run: return
   if not quiet:
     message = 'Test Every 5 Minutes'
     ZopeTestCase._print('\n%s ' % message)
     LOG('Testing... ',0,message)
   alarm = self.newAlarm(enabled=True)
   now = DateTime()
   minute_to_remove = now.minute() % 5
   now = addToDate(now,minute=-minute_to_remove)
   date = addToDate(now,day=2)
   alarm.setPeriodicityStartDate(date)
   alarm.setPeriodicityMinuteFrequency(5)
   self.tic()
   alarm.setNextAlarmDate(current_date=now)
   self.assertEqual(alarm.getAlarmDate(),date)
   LOG(message + ' now :',0,now)
   now = addToDate(now,day=2)
   LOG(message + ' now :',0,now)
   alarm.setNextAlarmDate(current_date=now)
   next_date = addToDate(date,minute=5)
   self.assertEqual(alarm.getAlarmDate(),next_date)
   now = addToDate(now,minute=5,second=14)
   alarm.setNextAlarmDate(current_date=now)
   next_date = addToDate(next_date,minute=5)
   self.assertEqual(alarm.getAlarmDate(),next_date)

 def testConstructor5(self):
     # Constructor from time float and timezone
     dt = DateTime()
     dt1 = DateTime(float(dt), dt.timezone())
     self.assertEqual(str(dt), str(dt1), (dt, dt1))
     dt1 = DateTime(float(dt), unicode(dt.timezone()))
     self.assertEqual(str(dt), str(dt1), (dt, dt1))

 def testDayOfWeek(self):
     # Compare to the datetime.date value to make it locale independent
     expected = date(2000, 6, 16).strftime('%A')
     # strftime() used to always be passed a day of week of 0
     dt = DateTime('2000/6/16')
     s = dt.strftime('%A')
     self.assertEqual(s, expected, (dt, s))

 def test_04_migrateEmptyFolder(self):
   """
   migrate empty folder from btree to hbtree
   """
   # Create some objects
   self.assertEquals(self.folder.getIdGenerator(), '')
   self.assertEquals(len(self.folder), 0)
   self.assertEqual(len(self.folder.objectIds()), 0)
   # call migration script
   self.folder.migrateToHBTree(migration_generate_id_method=None,
                               new_generate_id_method="_generatePerDayId")
   self.tic()
   # check we now have a hbtree
   self.assertEqual(self.folder.isBTree(), False)
   self.assertEqual(self.folder.isHBTree(), True)
   self.assertEqual(len(self.folder.objectIds()), 0)
   # check new object ids
   obj1 = self.newContent()
   from DateTime import DateTime
   date = DateTime().Date()
   date = date.replace("/", "")
   self.failUnless(date in obj1.getId())
   # check we still have a hbtree
   self.assertEqual(self.folder.isBTree(), False)
   self.assertEqual(self.folder.isHBTree(), True)
   self.assertEqual(len(self.folder.objectIds()), 1)

def isExpired(content):
    """ Find out if the object is expired (copied from skin script) """

    expiry = None

    # NOTE: We also accept catalog brains as 'content' so that the
    # catalog-based folder_contents will work. It's a little magic, but
    # it works.

    # ExpirationDate should have an ISO date string, which we need to
    # convert to a DateTime

    # Try DC accessor first
    if base_hasattr(content, 'ExpirationDate'):
        expiry = content.ExpirationDate

    # Try the direct way
    if not expiry and base_hasattr(content, 'expires'):
        expiry = content.expires

    # See if we have a callable
    if safe_callable(expiry):
        expiry = expiry()

    # Convert to DateTime if necessary, ExpirationDate may return 'None'
    if expiry and expiry != 'None' and isinstance(expiry, basestring):
        expiry = DateTime(expiry)

    if isinstance(expiry, DateTime) and expiry.isPast():
        return 1
    return 0

def adapter_enforce_gmt(dt=None):
    if dt != None:
        dt = DateTime(dt)
        t = dt.timeTime()
        gmt_date = DateTime(t,gmt_offset(dt))
        return gmt_date
    return DateTime()

 def modified(self):
     """Provide a callable to return the modification time of content
     items, so stored image scales can be invalidated.
     """
     context = aq_base(self.context)
     date = DateTime(context._p_mtime)
     return date.millis()

 def purge_now(self):
     last_purge = self.last_purge()
     now = DateTime()
     if (not last_purge) or now - last_purge > 30 or now.month() != last_purge.month():
         return True
     else:
         return False

def datehandler(value):
    # TODO: we might want to handle datetime and time as well;
    # check the enfold.solr implementation
    if value is None or value is '':
        raise AttributeError
    if isinstance(value, str) and not value.endswith('Z'):
        try:
            value = DateTime(value)
        except SyntaxError:
            raise AttributeError

    if isinstance(value, DateTime):
        v = value.toZone('UTC')
        value = '%04d-%02d-%02dT%02d:%02d:%06.3fZ' % (
            v.year(), v.month(), v.day(), v.hour(), v.minute(), v.second()
        )
    elif isinstance(value, datetime):
        # Convert a timezone aware timetuple to a non timezone aware time
        # tuple representing utc time. Does nothing if object is not
        # timezone aware
        value = datetime(*value.utctimetuple()[:7])
        value = '%s.%03dZ' % (
            value.strftime('%Y-%m-%dT%H:%M:%S'),
            value.microsecond % 1000
        )
    elif isinstance(value, date):
        value = '%s.000Z' % value.strftime('%Y-%m-%dT%H:%M:%S')
    return value

  def newTrashBin(self, bt_title='trash', bt=None):
    """
      Create a new trash bin at upgrade of bt
    """
    # construct date
    date = DateTime()
    start_date = date.strftime('%Y-%m-%d')

    def getBaseTrashId():
      ''' A little function to get an id without leading underscore
      '''
      base_id = '%s' % start_date
      if bt_title not in ('', None):
        base_id = '%s_%s' % (bt_title, base_id)
      return base_id

    # generate id
    trash_ids = self.objectIds()
    n = 0
    new_trash_id = getBaseTrashId()
    while new_trash_id in trash_ids:
      n += 1
      new_trash_id = '%s_%s' % (getBaseTrashId(), n)
    # create trash bin
    trashbin = self.newContent( portal_type     = 'Trash Bin'
                              , id              = new_trash_id
                              , title           = bt_title
                              , start_date      = start_date
                              , causality_value = bt
                              )
    return trashbin

    def lectureTakesPlace(self, datetime=None):
        """
        Return True if the lecture takes place on the given date. If
        no date is specified, the current date will be used.

        TODO: Currently not implemented for monthly and yearly recurrence.
        """
        
        result = False
        if not datetime:
            datetime = DateTime()

        if datetime >= self.startDate.earliestTime() \
               and datetime <= self.endDate.latestTime():
            if self.recurrence == NO_RECURRENCE:
                result = self.startDate.isCurrentDay()
            elif self.recurrence == DAILY:
                result = True
            elif self.recurrence == WEEKLY:
                result = datetime.dow() == self.startDate.dow()
            elif self.recurrence == MONTHLY:
                # TODO
                result = False
            elif self.recurrence == YEARLY:
                # TODO
                result = False
        return result

    def _createOrderId(self):
        """Creates a new unique order id.
        """
        from DateTime import DateTime;
        now = DateTime()

        return str(now.millis())

    def handle_event(self, instance, event):
        # Note this event
        self._stats.incr(self.STAT_FORMAT.format(region=instance.region.name, event_code=event.code))

        # GOTCHA: DateTime arithmatics are done in days. Convert hours into days.
        threshold_time = DateTime(event.not_before) - (float(self.urgent_threshold) / 24)
        msg = self.MESSAGE_FORMAT.format(
            az=instance.placement,
            name=instance.tags['Name'],
            code=event.code,
            id=instance.id,
            description=event.description,
            start_time=event.not_before,
            end_time=event.not_after,
        )
        if threshold_time.isFuture():
            # The event will happen after the threshold time.
            # Just regular notification will suffice.
            self._logger.debug('This event is not urgent yet: %s', msg)
            self._regular_events.append(msg)
        else:
            # The event will happen within the next threshold time.
            # Highlight this event.
            self._logger.debug('This event is urgent: %s', msg)
            self._urgent_events.append(msg)