def prepara_certificado_txt(self, cert_txt):
        #
        # Para dar certo a leitura pelo xmlsec, temos que separar o certificado
        # em linhas de 64 caracteres de extensão...
        #
        cert_txt = cert_txt.replace('\n', '')
        cert_txt = cert_txt.replace('-----BEGIN CERTIFICATE-----', '')
        cert_txt = cert_txt.replace('-----END CERTIFICATE-----', '')

        linhas_certificado = ['-----BEGIN CERTIFICATE-----\n']
        for i in range(0, len(cert_txt), 64):
            linhas_certificado.append(cert_txt[i:i+64] + '\n')
        linhas_certificado.append('-----END CERTIFICATE-----\n')

        self.certificado = ''.join(linhas_certificado)

        cert_openssl = crypto.load_certificate(crypto.FILETYPE_PEM, self.certificado)
        self.cert_openssl = cert_openssl

        self._emissor = dict(cert_openssl.get_issuer().get_components())
        self._proprietario = dict(cert_openssl.get_subject().get_components())
        self._numero_serie = cert_openssl.get_serial_number()
        self._data_inicio_validade = datetime.strptime(cert_openssl.get_notBefore(), '%Y%m%d%H%M%SZ')
        self._data_inicio_validade = UTC.localize(self._data_inicio_validade)
        self._data_fim_validade    = datetime.strptime(cert_openssl.get_notAfter(), '%Y%m%d%H%M%SZ')
        self._data_fim_validade    = UTC.localize(self._data_fim_validade)

        for i in range(cert_openssl.get_extension_count()):
            extensao = cert_openssl.get_extension(i)
            self._extensoes[extensao.get_short_name()] = extensao.get_data()

def unixtimestamp(datetime):
    """Get unix time stamp from that given datetime. If datetime
    is not tzaware then it's assumed that it is UTC
    """
    epoch = UTC.localize(datetime.utcfromtimestamp(0))
    if not datetime.tzinfo:
        dt = UTC.localize(datetime)
    else:
        dt = UTC.normalize(datetime)
    delta = dt - epoch
    return total_seconds(delta)

    def on_topicinfo(self, c, e):
        model.Session.remove()
        args = e.arguments()
        log.debug(args)
        channel = args[0].lstrip(''.join(CHANNEL_PREFIXES))
        changed_by = args[1]
        changed_on = UTC.localize(datetime.utcfromtimestamp(float(args[2])))

        channel_participation_id = self.channels[channel]
        channel_participation = model.Session.query(model.ChannelParticipation) \
            .get(channel_participation_id)
        channel_info = model.Session.query(model.ChannelTopicInfo) \
                        .get(channel_participation_id)
        if not channel_info:
            log.debug('on_topicinfo ChannelTopicInfo for %s non-existant' % channel)
            channel_info = model.ChannelTopicInfo(channel_participation,
                                                  changed_by, changed_on)
        else:
            if channel_info.changed_by != changed_by or \
                channel_info.changed_on != changed_on:
                log.debug(self.__class__.__name__ + ' updating topic info for channel %s...' % channel)
                if channel_info.changed_by != changed_by:
                    channel_info.changed_by = changed_by
                if channel_info.changed_on != changed_on:
                    channel_info.changed_on = changed_on
        model.Session.save(channel_info)
        model.Session.commit()

def format_date(date, tzinfo=None):

    ### TODO: calling this function with the Plone default datetime (year=1000)
    ### will generate exceptions.  This case must be handled
    ### This can be aggrivated by requesting an article that does not exist, 
    ### through articles.xml view, among other ways.

    #Are we a datetime or a DateTime?
    if hasattr(date, 'utcdatetime'): #we are a Zope DateTime!
        date = date.utcdatetime()

    #else: #we are a python datetime!
    #    date = date

    #calling this function 'naive' will attach a UTC timezone
    if date.tzinfo is None and tzinfo is None:
        date = UTC.localize(date)

    #calling this function with a tzinfo arg will:
    elif tzinfo is not None:
        if date.tzinfo is None: #localize an existing naive datetime
            date = tzinfo.localize(date)
        else: #convert a non-naive datetime into the provided timezone
            date = date.astimezone(tzinfo)

    if date.tzinfo.tzname(date) is not None:
        return date.strftime("%a, %d %b %Y %H:%M:%S %Z")
    else: #we only have a UTC offset
        return date.strftime("%a, %d %b %Y %H:%M:%S %z")

    def load_resp(self, resp, is_download):
        """
        Loads json response from API.

        :param resp: Response from API
        :type resp: dictionary
        :param is_download: Calculates time taken based on 'updated' field in response if upload, and based on stop time if download
        :type is_download: boolean
        """

        assert isinstance(resp, dict)
        setattr(self, 'resp', resp)
        setattr(self, 'size', humanize.naturalsize(int(resp['size'])))

        if is_download:
            updated_at = datetime.now(UTC)
        else:
            updated_at = UTC.localize(datetime.strptime(resp['updated'], '%Y-%m-%dT%H:%M:%S.%fZ'))

        setattr(self, 'time_taken', dict(zip(
            ('m', 's'),
            divmod((updated_at - getattr(self, 'start_time')).seconds if updated_at > getattr(self, 'start_time') else 0, 60)
        )))

        setattr(self, 'full_path', 'gs://%s/%s' % (resp['bucket'], resp['name']))

def to_utc(dt):
    if not isinstance(dt, datetime):
        dt = datetime(dt.year, dt.month, dt.day)
    if dt.tzinfo is None:
        return UTC.localize(dt)
    else:
        return dt.astimezone(UTC)

    def build_feed(self):
        "Build the feed given our existing URL"
        # Get all the episodes
        page_content = str(requests.get(self.url).content)
        parser = BassdriveParser()
        parser.feed(page_content)
        links = parser.get_links()

        # And turn them into something usable
        fg = FeedGenerator()
        fg.id(self.url)
        fg.title(self.title)
        fg.description(self.title)
        fg.author({'name': self.dj})
        fg.language('en')
        fg.link({'href': self.url, 'rel': 'alternate'})
        fg.logo(self.logo)

        for link in links:
            fe = fg.add_entry()
            fe.author({'name': self.dj})
            fe.title(link[0])
            fe.description(link[0])
            fe.enclosure(self.url + link[1], 0, 'audio/mpeg')

            # Bassdrive always uses date strings of
            # [yyyy.mm.dd] with 0 padding on days and months,
            # so that makes our lives easy
            date_start = link[0].find('[')
            date_str = link[0][date_start:date_start+12]
            published = datetime.strptime(date_str, '[%Y.%m.%d]')
            fe.pubdate(UTC.localize(published))
            fe.guid((link[0]))

        return fg

def activities_and_calories(gauge_factory, config, logger):
    activity_gauge = gauge_factory('runkeeper.activities')
    calorie_gauge = gauge_factory('runkeeper.calories_burned')
    local_tz = timezone(config['runkeeper.local_tz'])

    user = healthgraph.User(session=healthgraph.
                            Session(config['runkeeper.access_token']))
    activities_iter = user.get_fitness_activity_iter()

    today = today_utc().date()
    today_activities = []
    for a in activities_iter:  # breaking early prevents loading all results
        activity_time = a['start_time'].replace(tzinfo=local_tz)
        activity_time_utc = UTC.normalize(activity_time)
        day = activity_time_utc.date()
        if day == today:
            today_activities.append(a)
        elif (today - day).days > 2:
            break

    total_activities = len(today_activities)
    total_calories = int(sum([a['total_calories'] for a in today_activities]))

    activity_gauge.save(today_utc(), total_activities)
    calorie_gauge.save(today_utc(), total_calories)
    logger.info('Saved {0} activities ({1} cal) for {2}'
                .format(total_activities, total_calories, today_utc()))

    def load(self, timestamp):
        """Return (stored_datetime, loaded_datetime).

        The stored_datetime is the timestamp actually stored in
        Postgres, which may or may not be the timestamp we saved. The
        loaded_datetime is the timestamp we end up with using this
        method.
        """
        select = {
            'timestamp_explicit':
            "timestamp at time zone '{}'".format(self.tz.zone),
            'timestamp_stored': "timestamp at time zone 'UTC'",
        }

        loaded_attr = ('timestamp' if self.conversion == 'implicit'
                       else 'timestamp_explicit')

        qs = Timestamp.objects.extra(select=select)

        timestamp = qs.get(pk=timestamp.pk)

        stored_datetime = UTC.localize(timestamp.timestamp_stored)
        loaded_datetime = self.tz.localize(getattr(timestamp, loaded_attr))

        return stored_datetime, loaded_datetime

def list_events():
    """List events for ajax supplied start and end."""
    start = request.args.get('start', 0, type=int)
    end = request.args.get('end', 0, type=int)
    # make a datetime from the timestamp
    start = datetime.datetime.fromtimestamp(start)
    end = datetime.datetime.fromtimestamp(end)
    # Fetch the events from MongoDB
    _events = Event.query.filter(Event.timestamp >= start, Event.timestamp <= end)
    # Build the json so FullCalendar will swallow it
    events = []
    for event in _events:
        # Localize the time and get rid of the microseconds
        event_start = UTC.localize(event.timestamp).astimezone(timezone('US/Central')).replace(microsecond=0)
        # Make the event 5 minutes
        event_end = (event_start + datetime.timedelta(minutes=5)).replace(microsecond=0)
        event_dict = {'title' : event.context.description,
                      'id' : event.id,
                      'allDay' : False,
                      'start' : event_start.isoformat(),
                      'end' : event_end.isoformat(),
                      'url' : '/event/{0}'.format(event.id)} # Url for the event detail
        if event.context.status != 0:
            event_dict.update({'color' : 'red'})
        events.append(event_dict)
    return json.dumps(events)

 def handle(self, *args, **options):
     if Vaccine.objects.exists() or Pet.objects.exists():
         print('Pet data already loaded...exiting.')
         print(ALREADY_LOADED_ERROR_MESSAGE)
         return
     print("Creating vaccine data")
     for vaccine_name in VACCINES_NAMES:
         vac = Vaccine(name=vaccine_name)
         vac.save()
     print("Loading pet data for pets available for adoption")
     for row in DictReader(open('./pet_data.csv')):
         pet = Pet()
         pet.name = row['Pet']
         pet.submitter = row['Submitter']
         pet.species = row['Species']
         pet.breed = row['Breed']
         pet.description = row['Pet Description']
         pet.sex = row['Sex']
         pet.age = row['Age']
         raw_submission_date = row['submission date']
         submission_date = UTC.localize(
             datetime.strptime(raw_submission_date, DATETIME_FORMAT))
         pet.submission_date = submission_date
         pet.save()
         raw_vaccination_names = row['vaccinations']
         vaccination_names = [name for name in raw_vaccination_names.split('| ') if name]
         for vac_name in vaccination_names:
             vac = Vaccine.objects.get(name=vac_name)
             pet.vaccinations.add(vac)
         pet.save()

 def test_timezone(self):
     dt = datetime(2009, 11, 10, 23, 0, 0, 123456)
     utc = UTC.localize(dt)
     berlin = timezone('Europe/Berlin').localize(dt)
     eastern = berlin.astimezone(timezone('US/Eastern'))
     data = {
         "points": [
             {"measurement": "A", "fields": {"val": 1},
              "time": 0},
             {"measurement": "A", "fields": {"val": 1},
              "time": "2009-11-10T23:00:00.123456Z"},
             {"measurement": "A", "fields": {"val": 1}, "time": dt},
             {"measurement": "A", "fields": {"val": 1}, "time": utc},
             {"measurement": "A", "fields": {"val": 1}, "time": berlin},
             {"measurement": "A", "fields": {"val": 1}, "time": eastern},
         ]
     }
     self.assertEqual(
         line_protocol.make_lines(data),
         '\n'.join([
             'A val=1i 0',
             'A val=1i 1257894000123456000',
             'A val=1i 1257894000123456000',
             'A val=1i 1257894000123456000',
             'A val=1i 1257890400123456000',
             'A val=1i 1257890400123456000',
         ]) + '\n'
     )

def _convert_timestamp(timestamp, precision=None):
    if isinstance(timestamp, Integral):
        return timestamp  # assume precision is correct if timestamp is int

    if isinstance(_get_unicode(timestamp), text_type):
        timestamp = parse(timestamp)

    if isinstance(timestamp, datetime):
        if not timestamp.tzinfo:
            timestamp = UTC.localize(timestamp)

        ns = (timestamp - EPOCH).total_seconds() * 1e9
        if precision is None or precision == 'n':
            return ns
        elif precision == 'u':
            return ns / 1e3
        elif precision == 'ms':
            return ns / 1e6
        elif precision == 's':
            return ns / 1e9
        elif precision == 'm':
            return ns / 1e9 / 60
        elif precision == 'h':
            return ns / 1e9 / 3600

    raise ValueError(timestamp)

 def to_mobile_date(self, cr, uid, model_date):
     user = self.pool.get('res.users').browse(cr, uid, uid)
     local_tz = pytz.timezone(user.partner_id.tz)
     fecha = datetime.strptime(model_date, tools.DEFAULT_SERVER_DATETIME_FORMAT)
     fecha = UTC.localize(fecha, is_dst=False)
     fecha = fecha.astimezone(local_tz)
     return fecha.strftime('%d/%m/%Y %H:%M:%S')

def login_patch(auth, username=None, password=None):
    if ((username is None and password is None) or
        (username == 'jane' and password == 'secret')):
        auth._token = '1a2b3c'
        auth._lifespan = 3600
        auth._expires = UTC.localize(datetime.now() + timedelta(hours=1))
        return True
    raise AuthenticationFailed()

def apply_tzdatabase_timezone(date_time, pytz_string):
    date_time = UTC.localize(date_time)
    usr_timezone = timezone(pytz_string)

    if date_time.tzinfo != usr_timezone:
        date_time = date_time.astimezone(usr_timezone)

    return date_time.replace(tzinfo=None)

def localize_timezone(datetime, tz=None):
    if not datetime.tzinfo:
        datetime = UTC.localize(datetime)
    if not tz:
        tz = get_timezone()
    if isinstance(tz, basestring):
        tz = timezone(tz)
    return datetime.astimezone(tz)

 def _assert_release_by_creator(creator, spr):
     release_records = store.find(
         LatestPersonSourcePackageReleaseCache,
         LatestPersonSourcePackageReleaseCache.creator_id == creator.id)
     [record] = list(release_records)
     self.assertEqual(spr.creator, record.creator)
     self.assertIsNone(record.maintainer_id)
     self.assertEqual(
         spr.dateuploaded, UTC.localize(record.dateuploaded))

def apply_timezone(date_time, tz_string):
    if not date_time.tzinfo:
        date_time = UTC.localize(date_time)

    new_datetime = apply_dateparser_timezone(date_time, tz_string)

    if not new_datetime:
        new_datetime = apply_tzdatabase_timezone(date_time, tz_string)

    return new_datetime

 def __init__(self, channel_participation, type, source, message, subtype=None):
     self.channel_participation = channel_participation
     self.channel_participation_id = channel_participation.id
     self.type = type
     self.subtype = subtype
     self.source = source
     self.msg = message
     self.stamp = UTC.localize(datetime.datetime.utcnow())
     self.channel_participation.channel.update_last_entry(self.stamp)
     Session.save(self.channel_participation.channel)