def process_users(self, items):
  users = self.session.users
  for (i, item) in enumerate(items):
# Tweets
   if 'user' in item:
    if unicode(item['user']['id']) not in users:
     with self.session.storage_lock: users[unicode(item['user']['id'])] = {}
    if '_last_update' not in users[unicode(item['user']['id'])] or time.mktime(rfc822.parsedate(item['created_at'])) > time.mktime(rfc822.parsedate(users[unicode(item['user']['id'])]['_last_update'])):
     item['user']['_last_update'] = item['created_at']
     with self.session.storage_lock: users[unicode(item['user']['id'])].update(item['user'])
    item['user'] = users[unicode(unicode(item['user']['id']))]
# Retweets
   if 'retweeted_status' in item and 'user' in item['retweeted_status']:
    if unicode(item['retweeted_status']['user']['id']) not in users:
     with self.session.storage_lock: users[unicode(item['retweeted_status']['user']['id'])] = {}
    if '_last_update' not in users[unicode(item['retweeted_status']['user']['id'])] or time.mktime(rfc822.parsedate(item['retweeted_status']['created_at'])) > time.mktime(rfc822.parsedate(users[unicode(item['retweeted_status']['user']['id'])]['_last_update'])):
     item['retweeted_status']['user']['_last_update'] = item['retweeted_status']['created_at']
     with self.session.storage_lock: users[unicode(item['retweeted_status']['user']['id'])].update(item['retweeted_status']['user'])
    item['retweeted_status']['user'] = users[unicode(item['retweeted_status']['user']['id'])]
# Direct messages
   if 'sender' in item:
    if unicode(item['sender']['id']) not in users:
     with self.session.storage_lock: users[unicode(item['sender']['id'])] = {}
    if '_last_update' not in users[unicode(item['sender']['id'])] or time.mktime(rfc822.parsedate(item['created_at'])) > time.mktime(rfc822.parsedate(users[unicode(item['sender']['id'])]['_last_update'])):
     item['sender']['_last_update'] = item['created_at']
     with self.session.storage_lock: users[unicode(item['sender']['id'])].update(item['sender'])
    item['sender'] = users[unicode(item['sender']['id'])]
   if 'recipient' in item:
    if unicode(item['recipient']['id']) not in users:
     with self.session.storage_lock: users[unicode(item['recipient']['id'])] = {}
    if '_last_update' not in users[unicode(item['recipient']['id'])] or time.mktime(rfc822.parsedate(item['created_at'])) > time.mktime(rfc822.parsedate(users[unicode(item['recipient']['id'])]['_last_update'])):
     item['recipient']['_last_update'] = item['created_at']
     with self.session.storage_lock: users[unicode(item['recipient']['id'])].update(item['recipient'])
    item['recipient'] = users[unicode(item['recipient']['id'])]
  return items

 def __call__(self, environ, start_response):
     """Respond to a request when called in the usual WSGI way."""
     path_info = environ.get('PATH_INFO', '')
     full_path = self._full_path(path_info)
     if not self._is_under_root(full_path):
         return self.not_found(environ, start_response)
     if path.isdir(full_path):
         if full_path[-1] <> '/' or full_path == self.root:
             location = util.request_uri(environ, include_query=False) + '/'
             if environ.get('QUERY_STRING'):
                 location += '?' + environ.get('QUERY_STRING')
             headers = [('Location', location)]
             return self.moved_permanently(environ, start_response, headers)
         else:
             full_path = self._full_path(path_info + self.index_file)
     try:
         sz = int(environ['CONTENT_LENGTH'])
     except:
         sz = 0
     if environ['REQUEST_METHOD'] == 'PUT' and sz > 0:
         for putglob in self.puttable:
             if fnmatch(path_info, putglob):
                 data = environ['wsgi.input'].read(sz)
                 try:
                     with open(full_path, "wb") as f: f.write(data)
                     return self.success_no_content(environ, start_response)
                 except:
                     print sys.exc_info()[1]
                     return self.server_error(environ, start_response)
     if environ['REQUEST_METHOD'] not in ('GET', 'HEAD'):
         headers = [('Allow', 'GET, HEAD')]
         return self.method_not_allowed(environ, start_response, headers)
     content_type = self._guess_type(full_path)
     try:
         etag, last_modified = self._conditions(full_path, environ)
         headers = [('Date', rfc822.formatdate(time.time())),
                    ('Last-Modified', last_modified),
                    ('ETag', etag)]
         if_modified = environ.get('HTTP_IF_MODIFIED_SINCE')
         if if_modified and (rfc822.parsedate(if_modified)
                             >= rfc822.parsedate(last_modified)):
             return self.not_modified(environ, start_response, headers)
         if_none = environ.get('HTTP_IF_NONE_MATCH')
         if if_none and (if_none == '*' or etag in if_none):
             return self.not_modified(environ, start_response, headers)
         file_like = self._file_like(full_path)
         headers.append(('Content-Type', content_type))
         start_response("200 OK", headers)
         if environ['REQUEST_METHOD'] == 'GET':
             return self._body(full_path, environ, file_like)
         else:
             return ['']
     except (IOError, OSError), e:
         print e
         return self.not_found(environ, start_response)

def guardar(RSS, resource, num, usuario):
    if resource == "rss":
        rss = RSS
    else:
        rss = resource
    try:
        d = feedparser.parse(rss)
        title = d.feed.title
        url = d.feed.link
        Rss = True
    except:
        Rss = False
    if Rss:
        try:
            logo = '<img src="'+d.feed.image.href+'">'
        except:
            logo = ""
        date = d.feed.published
        date = datetime.datetime.fromtimestamp(calendar.timegm(rfc822.parsedate(date)))
        # Guardar los nuevos canales de /canales
        try:
            T_Canal = Channels.objects.get(Title = title)
            T_Canal.Logo = logo
            T_Canal.RSS = rss
            T_Canal.Date = date
            T_Canal.Url = url
            T_Canal.NumMensaje = T_Canal.NumMensaje
        except Channels.DoesNotExist:
            T_Canal = Channels(Title = title, Logo = logo, RSS = rss, Date = date, Url = url, NumMensaje = 0)
        T_Canal.save()
        numNoticias = 0
        # Guardar las nuevas noticias de /canales/num
        for N_noticia in d.entries:
            titulo = N_noticia.title
            link = N_noticia.link
            date2 = N_noticia.published
            date2 = datetime.datetime.fromtimestamp(calendar.timegm(rfc822.parsedate(date2)))
            descripcion = N_noticia.description
            titular = d.feed.title
            try:
                T_num = CanalesNum.objects.get(Titulo = titulo, CanalId = T_Canal.id)
                T_num.Link = link
                T_num.Date = date2
                T_num.Descripcion = descripcion
                T_num.Titular = titular
            except CanalesNum.DoesNotExist:
                T_num = CanalesNum(Titulo = titulo, CanalId = T_Canal.id, Link = link, Date = date2, Descripcion = descripcion, Titular = titular)
                numNoticias = numNoticias + 1
            T_num.save()
        T_Canal.NumMensaje = T_Canal.NumMensaje + numNoticias
        T_Canal.save()
    # Si le das al boton de actualizar de /canales/num
    if resource != "rss":
        return HttpResponseRedirect("http://localhost:1234/canales/"+num)

    def index(self, req):
        """ Handle GET and HEAD requests for static files. Directory requests are not allowed"""
        static_dir = os.path.normpath(os.path.join(os.path.dirname(__file__), '../static/'))

        # filter out ..
        try:
            static_path = req.urlvars['path'].replace('/..', '')
        except:
            return HTTPForbidden()

        path = os.path.join(static_dir, static_path) 
        if os.path.isdir(path):
            return HTTPForbidden()

        if req.method == 'GET' or req.method == 'HEAD':
            if os.path.isfile(path):
                etag, modified, mime_type, size = self._get_stat(path)

                res = Response()
                res.headers['content-type'] = mime_type
                res.date = rfc822.formatdate(time.time())
                res.last_modified = modified
                res.etag = etag

                if_modified_since = req.headers.get('HTTP_IF_MODIFIED_SINCE')
                if if_modified_since:
                    if rfc822.parsedate(if_modified_since) >= rfc822.parsedate(last_modified):
                        return HTTPNotModified()

                if_none_match = req.headers.get('HTTP_IF_NONE_MATCH')
                if if_none_match:
                    if if_none_match == '*' or etag in if_none_match:
                        return HTTPNotModified()

                # set the response body
                if req.method == 'GET':
                    fd = open(path, 'rb')
                    if 'wsgi.file_wrapper' in req.environ:
                        res.app_iter = req.environ['wsgi.file_wrapper'](fd)
                        res.content_length = size
                    else:
                        res.app_iter = iter(lambda: fd.read(8192), '')
                        res.content_length = size
                else:
                    res.body = ''

                return res
            else:
                return None
        else:
            return None

def guardar(RSS, resource, num, usuario):
    if resource == "rss":
        rss = RSS
    else:
        rss = resource
    try:
        d = feedparser.parse(rss)
        Rss = True
    except UnboundLocalError:
        Rss = False
    if Rss:
        title = d.feed.title
        url = d.feed.link
        Num_Mensaje = len(d.entries)
        try:
            logo = '<img src="'+d.feed.image.href+'">'
        except:
            logo = ""
        date = d.feed.published
        date = datetime.datetime.fromtimestamp(calendar.timegm(rfc822.parsedate(date)))
        try:
            T_Canal = Channels.objects.get(Title = title)
            T_Canal.Logo = logo
            T_Canal.RSS = rss
            T_Canal.Date = date
            T_Canal.Url = url
            T_Canal.NumMensaje = Num_Mensaje
        except Channels.DoesNotExist:
            T_Canal = Channels(Title = title, Logo = logo, RSS = rss, Date = date, Url = url, NumMensaje = Num_Mensaje)
        T_Canal.save()
        for N_noticia in d.entries:
            titulo = N_noticia.title
            link = N_noticia.link
            date = N_d.published
            date = datetime.datetime.fromtimestamp(calendar.timegm(rfc822.parsedate(date)))
            descripcion = N_d.description
            titular = d.feed.title
            try:
                T_num = CanalNum.objects.get(Titulo = titulo, Titular = titular)
                T_num.Link = link
                T_num.Date = date
                T_num.Descripcion = descripcion
            except CanalNum.DoesNotExist:
                T_num = CanalNum(Titulo = titulo, Titular = titular, Link = link, Date = date, Descripcion = descripcion)
            T_num.save()
        try:
            T_Num = CanalNum.objects.get()
    if resource != "rss":
        return HttpResponseRedirect("http://localhost:1234/canales/"+num)

    def test_1(self):
        """
        Verify the handler reples with an accurate Last-Modified header.
        """

        bogus_start_response = mock.Mock()

        # Send a request to the handler.
        self.sh({'PATH_INFO': '/static/pitz.css'}, bogus_start_response)

        assert bogus_start_response.called

        assert bogus_start_response.call_args[0][0] == '200 OK', \
        bogus_start_response.call_args[0][0]

        headers = bogus_start_response.call_args[0][1]

        # Make sure that there's a Last-Modified header.
        values = [v for (k, v) in headers if k == 'Last-Modified']
        assert len(values) == 1, headers

        last_modified_header = values[0]

        assert self.modified_time == datetime.datetime(
            *(rfc822.parsedate( last_modified_header))[:6])

		def saveData(feed):
			santos = []
			for item in range(0, len(feed)):
				title = strip_accents(feed[item]['text'].encode('utf-8'))
				title = title.replace("\n", " ")
				
				# Regular Expression to get what I want
				reg_notice = re.compile('^(.*)(: http://.*)$').search(title)
				reg_jogo = re.compile('^(.*)( Siga AO VIVO por aqui!)$').search(title)
				if reg_jogo is not None:
					title = reg_jogo.groups()[0][:90]
				elif reg_notice is not None:
					title = reg_notice.groups()[0][:90]
				else:
					title = title[:90]
				
				reg_via = re.compile('^(.*) - Via .*$').search(title)
				if reg_via is not None:
					title = reg_via.groups()[0][:90]
				
				created_at = rfc822.parsedate(feed[item]['created_at'])
				if (time.mktime(created_at) >= (time.time() - (60*60*12))):
					santos.append({
				 					'created_at': created_at,
				 					'title': title
						  	   	  })
			return santos

    def update_cache(self, key, value, headers):
        cache = True
        expires = int(time()) + 3600

        expires = headers.get('Expires', None)
        if expires:
            expires = mktime(parsedate(expires))
        else:
            expires = int(time()) + 3600

        cache_control = headers.get('Cache-Control', '')
        for control in cache_control.split(','):
            control = control.strip(' ')
            control = control.split('=')
            if len(control) == 2:
                k, v = control
            else:
                k = control
                v = None

            if k in ('private', 'no-cache', 'no-store', 'must-revalidate'):
                cache = False

            if k in ('max-age', 'min-fresh'):
                try:
                    expires = int(time()) + int(v)
                except ValueError:
                    pass

        if cache:
            self.cache[key] = (expires, value)

    def parse_headers(self, header, meta):
        meta.title = header.get("Subject")

        if header.get("Message-Id"):
            meta.foreign_id = unicode(header.get("Message-Id"))

        if header.get("From"):
            addr = address.parse(header.get("From"))
            if addr is not None:
                meta.author = addr.to_unicode()
                meta.add_email(addr.address)

        for hdr in ["To", "CC", "BCC"]:
            if header.get(hdr):
                for addr in address.parse_list(header.get(hdr)):
                    meta.add_email(addr.address)

        date = header.get("Date")
        date = rfc822.parsedate(date)
        if date is not None:
            dt = datetime.fromtimestamp(mktime(date))
            meta.add_date(dt)

        meta.headers = dict([(k, unicode(v)) for k, v in header.items()])
        return meta

def my_tweets(request):
    if request.method == "POST":
        token = settings.TWITCN_PRIVATE_TOKEN
        api = getPrivateApi(token)
        info = "blank"
        if request.POST.get('action') == "save":
            max_id = request.POST.get('max_id', None)
            messages = api.GetUserTimeline(user='mitnk', max_id=max_id, count=50)
            count = 0
            for message in messages:
                if message.text[0] == "@" or \
                    MyTweet.objects.filter(tweet_id=message.id).count() > 0:
                    continue
                added = datetime.datetime(*rfc822.parsedate(message.created_at)[:6])
                MyTweet.objects.create(name=message.user.screen_name, 
                                       text=smart_str(message.text), 
                                       tweet_id=message.id, 
                                       added=added)
                count += 1
            info = "%s\n" % count
        return HttpResponse(info)

    messages = MyTweet.objects.filter(added__year=datetime.date.today().year)
    return render_to_response("webapps/favo_tweets.html",
        {'messages': messages},
        context_instance=RequestContext(request))

  def GetCreatedAtInSeconds(self):
    '''Get the time this status message was posted, in seconds since the epoch.

    Returns:
      The time this status message was posted, in seconds since the epoch.
    '''
    return timegm(rfc822.parsedate(self.created_at))

def has_modified_header(headers):
    """
    Check request header for 'if-modified-since'.

    Return True if content wasn't modified (According to the timestamp)
    """
    global DATA_LAST_MODIFIED

    modified = headers.get('if-modified-since')
    if modified:
        oldLastModified = DATA_LAST_MODIFIED
        try:
            mtime = path.getmtime(TMPFILE_DATA_TIMESTAMP)
        except OSError:
            with open(TMPFILE_DATA_TIMESTAMP, 'a'):
                utime(TMPFILE_DATA_TIMESTAMP, None)
            mtime = time()
        DATA_LAST_MODIFIED = email.utils.formatdate(mtime, usegmt=True)
        if DATA_LAST_MODIFIED != oldLastModified:
            # reload attributes if index changed
            get_attributes_values('ind_name_exact', CHECK_ATTR_FILTER)
        # pprint([headers, modified, DATA_LAST_MODIFIED, mtime])
        # pprint([mtime, rfc822.parsedate(modified), mktime(rfc822.parsedate(modified))])
        modified_file = datetime.fromtimestamp(mtime)
        modified_file = modified_file.replace(microsecond=0)
        modified_date = datetime.fromtimestamp(mktime(rfc822.parsedate(modified)))

        # pprint([
        #     'Data: ', modified_file,
        #     'Header: ', modified_date,
        #     modified_file <= modified_date,
        # ])
        if modified_file <= modified_date:
            return True
    return False

 def import_buffer (tablename, buffername):
  table = new.load_table(tablename)
  newtable = new.convert_table(table)
  buf = self.session.get_buffer_by_name(buffername)
  buf.storage.extend(newtable)
  buf.storage.sort(key=lambda a: calendar.timegm(rfc822.parsedate(a['created_at'])))
  buf.storage = misc.RemoveDuplicates(buf.storage, lambda x: x['id'])

  def validate(self):
    if self.rfc2822_re.match(self.value):
      import calendar
      value = parsedate(self.value)

      try:
        if value[0] > 1900:
          dow = datetime.date(*value[:3]).strftime("%a")
          if self.value.find(',')>0 and dow.lower() != self.value[:3].lower():
            self.log(IncorrectDOW({"parent":self.parent.name, "element":self.name, "value":self.value[:3]}))
            return
      except ValueError as e:
        self.log(InvalidRFC2822Date({"parent":self.parent.name, "element":self.name, "value":str(e)}))
        return

      if implausible_822(self.value):
        self.log(ImplausibleDate({"parent":self.parent.name,
          "element":self.name, "value":self.value}))
      else:
        self.log(ValidRFC2822Date({"parent":self.parent.name, "element":self.name, "value":self.value}))
    else:
      value1,value2 = '', self.value
      value2 = re.sub(r'[\\](.)','',value2)
      while value1!=value2: value1,value2=value2,re.sub('\([^(]*?\)',' ',value2)
      if not self.rfc822_re.match(value2.strip().lower()):
        self.log(InvalidRFC2822Date({"parent":self.parent.name, "element":self.name, "value":self.value}))
      else:
        self.log(ProblematicalRFC822Date({"parent":self.parent.name, "element":self.name, "value":self.value}))

def BuildText(tweet):
    text = tweet['text']

    text = text.replace('\r','').replace('\n','<br />')

    if 'entities' in tweet:
        for info in tweet['entities']['urls']:
            text = text.replace(
                info['url'],
                CreateLink(info['url'],info['expanded_url']))
        for info in tweet['entities']['hashtags']:
            text = text.replace(
                '#' + info['text'],
                CreateLink("//twitter.com/search/%23"+info['text'],'#'+info['text']))
        for info in tweet['entities']['user_mentions']:
            name = info['screen_name']
            text = text.replace(
                '@' + name,
                CreateLink("//twitter.com/"+name,'@'+name))

    text = '<div class="twitter-tweet"><span class="twitter-text">' + text + "</span>"

    created_at_str = calendar.timegm(rfc822.parsedate(tweet['created_at']))
    created_at = datetime.datetime.fromtimestamp(created_at_str)

    screen_name = tweet['user']['screen_name']
    id_str = tweet['id_str']
    
    text += " " + CreateLink("//twitter.com/%s/status/%s"%(screen_name, id_str), created_at.strftime("%H:%M:%S"), "twitter-permalink") + "</div>"

    return text

def BuildPost(timeline, day):
    if not isinstance(timeline, list):
        return None

    tweets = []

    for elem in timeline:
        # determine elem is tweet or not
        if 'user' not in elem or 'created_at' not in elem or 'text' not in elem:
            continue
        # maybe tweet

        created_at_str = calendar.timegm(rfc822.parsedate(elem['created_at']))
        created_at = datetime.datetime.fromtimestamp(created_at_str)

        # filter tweet at yesterday
        if day.year != created_at.year or day.month != created_at.month or day.day != created_at.day:
            continue

        text = BuildText(elem)
        tweets.append(text)

    post = "".join(reversed(tweets))
    #post = "<ul class=\"twitter-log\">\n  " + post + "\n</ul>";

    return post

def collect_tweets():
    """Collect new tweets about Firefox."""
    with statsd.timer('customercare.tweets.time_elapsed'):
        auth = tweepy.OAuthHandler(settings.TWITTER_CONSUMER_KEY,
                                   settings.TWITTER_CONSUMER_SECRET,
                                   secure=True)

        auth.set_access_token(settings.TWITTER_ACCESS_TOKEN,
                              settings.TWITTER_ACCESS_TOKEN_SECRET)

        api = tweepy.API(auth, parser=RawParser())

        search_options = {
            'q': 'firefox OR #fxinput OR @firefoxbrasil OR #firefoxos',
            'rpp': settings.CC_TWEETS_PERPAGE,  # Items per page.
            'result_type': 'recent',  # Retrieve tweets by date.
        }

        # If we already have some tweets, collect nothing older than what we
        # have.
        try:
            latest_tweet = Tweet.latest()
        except Tweet.DoesNotExist:
            log.debug('No existing tweets. Retrieving %d tweets from search.' % (
                settings.CC_TWEETS_PERPAGE))
        else:
            search_options['since_id'] = latest_tweet.tweet_id
            log.info('Retrieving tweets with id >= %s' % latest_tweet.tweet_id)

        # Retrieve Tweets
        try:
            raw_data = json.loads(str(api.search(**search_options)))
        except tweepy.TweepError, e:
            log.warning('Twitter request failed: %s' % e)
            return

        if not ('results' in raw_data and raw_data['results']):
            # Twitter returned 0 results.
            return

        # Drop tweets into DB
        for item in raw_data['results']:
            # Apply filters to tweet before saving
            # Allow links in #fxinput tweets
            statsd.incr('customercare.tweet.collected')
            item = _filter_tweet(item, allow_links='#fxinput' in item['text'])
            if not item:
                continue

            created_date = datetime.utcfromtimestamp(calendar.timegm(
                rfc822.parsedate(item['created_at'])))

            item_lang = item.get('iso_language_code', 'en')
            tweet = Tweet(tweet_id=item['id'], raw_json=json.dumps(item),
                          locale=item_lang, created=created_date)
            try:
                tweet.save()
                statsd.incr('customercare.tweet.saved')
            except IntegrityError:
                pass

def date_conversion(val):
    if re.match('^\d{4}\-\d\d\-\d\d$', val):
        # 2012-12-31
        val = time.mktime(datetime.strptime(val, '%Y-%m-%d').timetuple())
    elif re.match('^\d\d?\/\d\d\/\d{4}$', val):
        # 31/12/2012
        val = time.mktime(datetime.strptime(val, '%d/%m/%Y').timetuple())
    elif re.match('^\d\d?\.\d\d\.\d{4}$', val):
        # 31.12.2012
        val = time.mktime(datetime.strptime(val, '%d.%m.%Y').timetuple())
    elif re.match('^\d{4}\d{2}\d{2}$', val):
        # 20121231
        val = time.mktime(datetime.strptime(val, '%Y%m%d').timetuple())
    elif re.match('^(\w+\,\s+)?\d+ \w+ \d{4}\s+\d\d?\:\d\d(:\d\d)?', val) or re.match('^\w+,?\s+?\d+ \d{2-4}\s+\d\d?\:\d\d(:\d\d)?', val):
        # Jan 24 2003 15:26:20 +0000
        # Mon, 20 Dec 04 08:37:31 GMT
        # Sat, 13 May 2006 06:15 +0000
        # Mon, 01 Jul 2002 18:38:25
        # Mon, 26 Sep 2005 7:35:00 -0800
        # Thu, 23 Apr 2009 13:32:15 +1200
        # 26 Aug 2009 02:07:34 +0400
        import rfc822
        import datetime as dt
        # [year, month, day, hour, min, sec]
        yyyy, mm, dd, hh, mins, ss = rfc822.parsedate(val)[:-3]
        val = time.mktime(dt.datetime(yyyy, mm, dd, hh, mins, ss).timetuple())
        try:
            val = float(str(val))
        except ValueError:
            pass
    return val

def get_messages(host, user, password):
    """Download all messages (e.g. pages) from the mailbox

    Keyword arguments:
    host -- IMAP server
    user -- login connection information
    password -- password connection information

    See http://stackoverflow.com/questions/315362/properly-formatted-example-for-python-imap-email-access
    """
    M = imaplib.IMAP4_SSL(host)
    M.login(user, password)

    M.select()
    typ, data = M.search(None, 'UNSEEN')
    messages = []
    for num in data[0].split():
        typ, data = M.fetch(num, '(RFC822)')
        file = StringIO.StringIO(data[0][1])
        message = rfc822.Message(file)

        msgDate = time.mktime(rfc822.parsedate(message['date']))
        messages.append(create_event('IMAP',
                                      message['from'],
                                      message['to'],
                                      message['subject'],
                                      int(msgDate)))
    M.close()

    M.logout()

    log.info('Found %d unseen messages at %s', len(messages), host)
    return messages

    def connect(self,):

        urlparsed = requests.utils.urlparse(self.url)

        self.wc = WebDAVClient(host=urlparsed.netloc,
                               protocol=urlparsed.scheme)

        self.wc.setbasicauth(self.login.encode('utf-8'),
                             self.passwd.encode('utf-8'))
        time_delta = None

        local_time = datetime.datetime.utcnow()

        response = self.wc.options('/').headers.get('date')
        if response is None:
            response = self.wc.options('/').headers.get('Date')

        remote_datetime = \
            rfc822.parsedate(response)

        self.timedelta = time.mktime(local_time.utctimetuple()) \
            - time.mktime(remote_datetime)

        self._check_notes_folder()

        return time_delta