def process(self):
        """process meetings"""
        parser = etree.XMLParser(recover=True)
        r = requests.get(self.timerange_url)
        xml = r.text.encode('ascii','xmlcharrefreplace') 
        root = etree.fromstring(xml, parser=parser)

        for item in root[1].iterchildren():
            meeting = {}
            for e in item.iterchildren():
                meeting[e.tag] = e.text

            meeting['start_date'] = parse_date(meeting['sisbvcs'])
            meeting['end_date'] = parse_date(meeting['sisevcs'])
            meeting['tz_start_date'] = parse_date(meeting['sisbvcs'], tzinfo=utc).astimezone(self.tzinfo)
            meeting['tz_end_date'] = parse_date(meeting['sisevcs'], tzinfo=utc).astimezone(self.tzinfo)
            silfdnr = meeting['silfdnr']
            try:
                result = self.process_agenda(silfdnr)
                meeting.update(result)
            except Exception, e:
                meeting['ERROR'] = True
                print e
            meeting['_id'] = int(meeting['silfdnr'])
            self.db.meetings.save(meeting)

    def process(self):
        """process meetings"""
        parser = etree.XMLParser(recover=True)
        r = requests.get(self.timerange_url)
        xml = r.text.encode('ascii','xmlcharrefreplace') 
        root = etree.fromstring(xml, parser=parser)

        start_at = root.find("list")
        for item in start_at.iterchildren():
            meeting = {}
            for e in item.iterchildren():
                meeting[e.tag] = e.text

            meeting['start_date'] = parse_date(meeting['sisbvcs'])
            meeting['end_date'] = parse_date(meeting['sisevcs'])
            meeting['tz_start_date'] = parse_date(meeting['sisbvcs'], tzinfo=utc).astimezone(self.tzinfo)
            meeting['tz_end_date'] = parse_date(meeting['sisevcs'], tzinfo=utc).astimezone(self.tzinfo)
            silfdnr = meeting['silfdnr']
            print "processing meeting %s" %silfdnr
            try:
                result = self.process_agenda(silfdnr)
                meeting.update(result)
            except Exception, e:
                meeting['ERROR'] = True
                print "exception when trying to parse meeting %s" %silfdnr
                print e
            meeting['meeting_id'] = str(meeting['silfdnr'])
            meeting['_id'] = "%s:%s" %(self.city, silfdnr)
            meeting['city'] = self.city
            self.db.meetings.save(meeting)

def history(begin=None, end=None, week=False, month=False):
    if week or month:
        end = datetime.datetime.now()
        if week:
            begin = end - datetime.timedelta(days=7)
        if month:
            begin = end - datetime.timedelta(days=28)
    else:
        try:
            begin = utils.parse_date(begin, dtime=True)
        except ValueError:
            return 'Error: unable to parse date %s' % begin
        try:
            end = utils.parse_date(end, dtime=True)
        except ValueError:
            return 'Error: unable to parse date %s' % end
    cd = utils.compose_date
    if not begin <= end:
        return 'Error: %s is not before %s' % (cd(begin), cd(end))
    db = utils.read_db()
    days = [utils.compose_date(begin + datetime.timedelta(days=x)) for x in xrange(0,
        (end-begin).days)]
    matches = ['from: %s to: %s' % (cd(begin), cd(end))]
    for day in days:
        matches.append('%s: %s' % (day, utils.daily_points(day, db)))

    return '\n'.join(matches)

def tweets(uid,min_date=None,max_date=None,limit=100):
    "returns all the tweets for a user between min_date and max_date"
    start = parse_date(min_date)
    end = parse_date(max_date)
    limit = int(limit) if limit else None
    tweets = Tweet.find(
        (Tweet.user_id==int(uid)) &
        (Tweet.created_at.range(start,end)),
        limit=limit,
        sort=Tweet._id)
    return [t.to_d() for t in tweets]

    def get(self, args):
        """ Return the courses matching your query """

        # Parameters
        date_string = args['date']
        department = args['department']
        place = args['place']
        comment = args['comment']

        # Base query
        courses = Course.query

        # Apply filters
        if date_string:
            courses = courses.filter_by(date=parse_date(date_string))
        if place:
            courses = courses.filter_by(place=place)
        if department:
            courses = courses.filter_by(department=department)
        if comment:
            # Can be useful to select a group in a course
            courses = courses.filter_by(department=comment)

        # Do the query
        courses = courses.order_by(Course.time_begin).limit(1000).all()

        # Format it
        course_list = [course.__toJSON__() for course in courses]

        return course_list, 200

    def parse_template_3(self, element):
        """
        A template for joint proceedings of two workshops.

        Examples:
            - http://ceur-ws.org/Vol-1098/
            - http://ceur-ws.org/Vol-989/
        """
        workshop_1 = {'id': 1}
        workshop_2 = {'id': 2}
        summary = self.rex(element[1], [
            r"(joint\s+proceedings\s+of\s+([\s\w,]+)\(([a-zA-Z]+)['\s]?\d+\)[and,\s]+"
            r"([:\s\w-]+)\(([a-zA-Z]+)['\s]?\d+\)([\w\s\-.,^\(]*|[,\s]+workshops\s+of.*|[,\s]+co-located.*))Edited by.*",

            r"(proceedings\s+of\s+joint([\s\w,]+)\(([a-zA-Z]+)['\s]?\d{0,4}\)[and,\s]+"
            r"([:,\s\w-]+)\(([a-zA-Z]+)['\s]?\d{0,4}\)([\w\s\-.,^\(]*|[,\s]+workshops\s+of.*|[,\s]+co-located.*))Edited by.*"
        ], re.I | re.S)

        if len(summary.groups()) != 6:
            raise DataNotFound()

        title = summary.group(1)

        workshop_1['volume_number'] = workshop_2['volume_number'] = \
            WorkshopSummaryParser.extract_volume_number(element[0].get('href'))
        workshop_1['url'] = workshop_2['url'] = element[0].get('href')
        workshop_1['time'] = workshop_2['time'] = utils.parse_date(title)

        workshop_1['label'] = summary.group(2)
        workshop_1['short_label'] = summary.group(3)
        workshop_2['label'] = summary.group(4)
        workshop_2['short_label'] = summary.group(5)

        self.add_workshop(workshop_1)
        self.add_workshop(workshop_2)

    def parse_template_5(self, element):
        """
        A template for a workshop with the conference acronym and year in the name

        Examples:
            - http://ceur-ws.org/Vol-958/
        """
        workshop = {}
        title = rex.rex(element[1], r'(.*)Edited\s*by.*', re.I | re.S).group(1)

        workshop['volume_number'] = WorkshopSummaryParser.extract_volume_number(element[0].get('href'))
        label_part = rex.rex(element[0].text, r'(.*)\sat\s(\w{2,})\s(\d{4})[\s\.]*', re.I | re.S)
        workshop['label'] = label_part.group(1)
        workshop['conf_acronym'] = label_part.group(2)
        workshop['conf_year'] = label_part.group(3)
        workshop['url'] = element[0].get('href')
        workshop['time'] = utils.parse_date(title)
        try:
            workshop['edition'] = tonumber(
                rex.rex(title,
                        r'.*Proceedings(\s*of)?(\s*the)?\s*(\d{1,}|first|second|third|forth|fourth|fifth)[thrd]*'
                        r'.*Workshop.*',
                        re.I, default=None).group(3))
        except:
            #'edition' property is optional
            pass

        self.add_workshop(workshop)

    def parse_template_2(self, element):
        """
        A template for joint proceedings of two workshops:

        Examples:
            - http://ceur-ws.org/Vol-776/
        """
        workshop_1 = {'id': 1}
        workshop_2 = {'id': 2}
        summary = rex.rex(element[1], r'^\s*(proceedings\s+of\s+joint.*on.*\((\w+)\-(\w+)\s+\d+\).*)Edited by.*',
                          re.I | re.S)

        if len(summary.groups()) != 3:
            raise DataNotFound()

        title = summary.group(1)

        workshop_1['volume_number'] = workshop_2['volume_number'] = \
            WorkshopSummaryParser.extract_volume_number(element[0].get('href'))
        workshop_1['url'] = workshop_2['url'] = element[0].get('href')
        workshop_1['time'] = workshop_2['time'] = utils.parse_date(title)

        workshop_1['short_label'] = summary.group(2)
        workshop_2['short_label'] = summary.group(3)

        self.add_workshop(workshop_1)
        self.add_workshop(workshop_2)

def map_video(config):
    programId = config.get('programId')
    kind = config.get('kind')
    duration = int(config.get('duration') or 0) * \
        60 or config.get('durationSeconds')
    airdate = config.get('broadcastBegin')
    if airdate is not None:
        airdate = str(utils.parse_date(airdate))

    return {
        'label': utils.format_title_and_subtitle(config.get('title'), config.get('subtitle')),
        'path': plugin.url_for('play', kind=kind, program_id=programId),
        'thumbnail': config.get('imageUrl'),
        'is_playable': True,
        'info_type': 'video',
        'info': {
            'title': config.get('title'),
            'duration': duration,
            'genre': config.get('genrePresse'),
            'plot': config.get('shortDescription') or config.get('fullDescription'),
            'plotoutline': config.get('teaserText'),
            # year is not correctly used by kodi :(
            # the aired year will be used by kodi for production year :(
            # 'year': int(config.get('productionYear')),
            'country': [country.get('label') for country in config.get('productionCountries', [])],
            'director': config.get('director'),
            'aired': airdate
        },
        'properties': {
            'fanart_image': config.get('imageUrl'),
        }
    }

def getData(request):
    from wrcc.wea_server.libwea.products.listers import getData
    error = require(request, ['stn', 'sD', 'eD'])
    if error:
        return ErrorResponse(error)

    stn = request.args.get('stn')
    sD = parse_date(request.args.get('sD'))
    eD = parse_date(request.args.get('eD'))
    units_system = request.args.get('units', 'N')  # N (native) units by default

    try:
        result = getData(stn, sD, eD, units_system=units_system)
    except IOError:
        return ErrorResponse("No data available.")

    return JsonResponse(result)

def make_row(date_string, headline):
    date = parse_date(date_string)
    L.debug("Parsed date '{}' as {}".format(date_string, date))
    return OrderedDict([
        ('venue', 'LEAF on Bold Street'),
        ('date', date),
        ('headline', headline),
        ('url', 'http://www.thisisleaf.co.uk/#/on-bold-street/events/')
    ])

def check_date(d):
  if not isinstance(d, str):
    error(str(d) + ": invalid data type")
    return None
  try:
    return utils.parse_date(d)
  except Exception as e:
    error(d + ": " + str(e))
    return None

def make_row(day, headline):
    date = parse_date(day)
    L.debug("Parsed date '{}' as {}".format(day, date))
    return OrderedDict([
        ('venue', 'The Caledonia'),
        ('date', date),
        ('headline', headline),
        ('url', 'http://www.thecaledonialiverpool.com/whats-on/'),
    ])

def make_row(date_string, headline, url):
    L.debug("'{}' : '{}'".format(headline, date_string))
    date = parse_date(date_string)
    L.debug("Parsed date '{}' as {}".format(date_string, date))
    return OrderedDict([
        ('venue', "St George's Hall"),
        ('date', date),
        ('headline', headline),
        ('url', url),
    ])

def make_row(date_string, earliest_date, headline, url):
    L.debug("'{}' : '{}'".format(headline, date_string))
    date = parse_date(date_string, not_before=earliest_date)
    L.debug("Parsed date '{}' as {}".format(date_string, date))
    return OrderedDict([
        ('venue', "FACT"),
        ('date', date),
        ('headline', headline),
        ('url', url)
    ])

def make_row(date_string, headline, url, venue):
    date = parse_date(date_string)
    L.debug("Parsed date '{}' as {}".format(date_string, date))
    return OrderedDict([
        ('organiser', 'Philosophy In Pubs'),
        ('venue', venue),
        ('date', date),
        ('headline', headline),
        ('url', url)
    ])

def make_row(date_string, headline, url):
    date = parse_date(date_string)
    L.debug("Parsed date '{}' as {}".format(date_string, date))
    return OrderedDict([
        ('organiser', 'The Bluecoat'),
        ('venue', 'The Bluecoat'),
        ('date', date),
        ('headline', headline),
        ('url', url)
    ])

 def post(self, key):
     post = self.request.POST
     form_data = dict((k, post.get(k, ''))
                       for k in ('title', 'author', 'date', 'body'))
     template_dict = {'form_data': form_data, 'key': key, 'show_form' : True}
     if 'delete_article' in post:
         try:
             NewsArticle.get(Key(key)).delete()
         except datastore_errors.Error:
             template_dict['message'] = \
                 'Could not delete article with key %r.' % key
         else:
             template_dict['message'] = 'Article deleted.'
             template_dict['show_form'] = False
     else:
         try:
             date = utils.parse_date(form_data['date'])
         except ValueError:
             template_dict['message'] = \
                 'Date is not in the correct format (YYYY-MM-DD).'
         else:
             if key == 'new':
                 try:
                     article = NewsArticle(title=form_data['title'],
                                           author=form_data['author'],
                                           date=date,
                                           body=form_data['body'])
                     article.put()
                 except datastore_errors.Error:
                     template_dict['message'] = \
                         'Could not create new article.'
                 else:
                     template_dict['message'] = 'Article created.'
                     template_dict['show_form'] = False
             else:
                 try:
                     article = NewsArticle.get(Key(key))
                 except BadKeyError:
                     template_dict['message'] = \
                         'Could not find article with key %r.' % key
                 else:
                     article.title = form_data['title']
                     article.author = form_data['author']
                     article.date = date
                     article.body = form_data['body']
                     try:
                         article.put()
                     except datastore_errors.Error:
                         template_dict['message'] = \
                             'Could not save changes to article.'
                     else:
                         template_dict['form_data'] = article
                         template_dict['message'] = 'Changes saved.'
     self.render_template('edit', template_dict)

 def post(self):
     user_id = self.get_secure_cookie("user")
     taskname = self.get_argument("taskname", "")
     description = self.get_argument("description", "")
     date = parse_date(self.get_argument("datetime", ""))
     if taskname.strip():
         newitem = TaskItem(user_id=user_id,
                            taskname=taskname,
                            datetime_due=date,
                            description=description)
         self.db.create(newitem)
     self.redirect("/list")

 def parse_disturbances(self):
     """
     For a given trendline, for each segment between vertices, determine
     the stats for each "disturbance" and return a list of Disturbance
     objects
     """
     import utils
     it = iter(self.points)
     left_vertex = it.next()
     for p in it:
         if not p.vertex:
             continue
         start_yr = utils.parse_date(left_vertex.index_date).year
         end_yr = utils.parse_date(p.index_date).year
         yield Disturbance(
             start_yr,
             left_vertex.val_fit,
             left_vertex.val_fit - p.val_fit,  # TODO %?
             end_yr - start_yr
         )
         left_vertex = p