Пример #1
0
def export_activity(year):
    if not perm.admin.can():
        flask.abort(403)

    cols = [
        'nume',
        'propuneri-total',
        'propuneri-inlucru',
        'propuneri-acceptate',
        'propuneri-respinse',
        'luari-de-cuvant',
        'intrebari',
        'intrebari-locale',
    ]
    rows = (
        {
            'nume': row['name'],
            'propuneri-total': row['proposals_total'],
            'propuneri-inlucru': row['proposals_inprogress'],
            'propuneri-acceptate': row['proposals_approved'],
            'propuneri-respinse': row['proposals_rejected'],
            'luari-de-cuvant': row['transcripts'],
            'intrebari': row['questions'],
            'intrebari-locale': row['questions-local'],
        }
        for row in dal.get_mandate_activity(year=year)
    )
    data = buffer_on_disk(csv_lines(cols, rows))
    return csv_response(data)
Пример #2
0
def question_dump():
    cols = ['name', 'legislature', 'date', 'title', 'score']
    ask_query = (
        models.Ask.query
        .join(models.Ask.question)
        .options(
            joinedload('question'),
            joinedload('mandate'),
            joinedload('mandate.person'),
            joinedload('match_row'),
        )
        .order_by(models.Question.date.desc())
    )
    def make_row(ask):
        score = ask.match.score
        return {
            'name': ask.mandate.person.name,
            'legislature': str(ask.mandate.year),
            'date': str(ask.question.date),
            'title': str(ask.question.title),
            'score': '' if score is None else str(score),
        }
    rows = (make_row(ask) for ask in ask_query.yield_per(10))
    data = buffer_on_disk(csv_lines(cols, rows))
    return flask.Response(data, mimetype='text/csv')
Пример #3
0
def export_policy():
    policy_slugs = [p['slug'] for p in dal.get_policy_list()]

    cols = ['nume']
    for policy_slug in policy_slugs:
        cols.extend([
            policy_slug + '-procent',
            policy_slug + '-propuneri',
            policy_slug + '-intrebari',
        ])

    ZERO = {'proposal_count': 0, 'question_count': 0, 'interest': 0}

    def policy_row(mandate_info):
        rv = {'nume': mandate_info['name']}
        person = dal.get_person(mandate_info['person_slug'])
        policy_map = {p['slug']: p for p in person.get_top_policies()}
        for policy_slug in policy_slugs:
            p = policy_map.get(policy_slug, ZERO)
            rv.update({
                policy_slug + '-procent': p['interest'],
                policy_slug + '-propuneri': p['proposal_count'],
                policy_slug + '-intrebari': p['question_count'],
            })
        return rv

    def mandates():
        mandates_by_county = dal.get_2016_mandates_by_county()
        for county_list in mandates_by_county.values():
            for mandate_info in county_list:
                yield mandate_info

    rows = (policy_row(m) for m in mandates())
    data = buffer_on_disk(csv_lines(cols, rows))
    return csv_response(data)
Пример #4
0
def export_proposals(year):
    if not perm.admin.can():
        flask.abort(403)

    cols = [
        'nr-cdep',
        'nr-senat',
        'nr-bpi',
        'data-propunere',
        'data-actualizare',
        'status',
        'titlu',
        'url-cdep',
        'url-senat',
        'initiatori-cdep',
        'initiatori-senat',
    ]
    rows = (
        {
            'nr-cdep': row['number_cdep'],
            'nr-senat': row['number_senate'],
            'nr-bpi': row['number_bpi'],
            'data-propunere': row['date'].isoformat(),
            'data-actualizare': row['modification_date'].isoformat(),
            'status': PROPOSAL_STATUS_LABEL[row['status']],
            'titlu': row['title'],
            'url-cdep': row['url_cdep'],
            'url-senat': row['url_senate'],
            'initiatori-cdep': row['namelist_cdep'],
            'initiatori-senat': row['namelist_senate'],
        }
        for row in dal.get_all_proposals(year=year)
    )
    data = buffer_on_disk(csv_lines(cols, rows))
    return csv_response(data)
Пример #5
0
def export_bounded_mandates(rq):
    out_list = [
        {
            'nume': row['name'],
            'partid': row['group'],
            'inceput': row['start'].isoformat(),
            'sfarsit': row['end'].isoformat(),
        }
        for row in dal.get_bounded_mandates(rq)
    ]
    cols = ['nume', 'partid', 'inceput', 'sfarsit']
    return csv_response(csv_lines(cols, out_list))
Пример #6
0
def export_votes(year):
    cols = ['data', 'cod cdep', 'nume', 'vot', 'vot grup']
    rows = (
        {
            'data': row['date'].isoformat(),
            'cod cdep': row['cdeppk'],
            'nume': row['name'],
            'vot': VOTE_LABEL.get(row['choice'], ''),
            'vot grup': VOTE_LABEL.get(row['group_choice'], ''),
        }
        for row in dal.get_all_votes(year=year)
    )
    data = buffer_on_disk(csv_lines(cols, rows))
    return csv_response(data)
Пример #7
0
def dump():
    voting_sessions = (
        models.VotingSession.query
            .order_by(
                models.VotingSession.date,
                models.VotingSession.cdeppk,
            ))

    def iter_rows():
        for voting_session in voting_sessions:
            cols_voting_session = {
                'data': str(voting_session.date),
                'titlu': voting_session.subject,
                'cod cdep': voting_session.cdeppk,
                'link cdep': voting_session.cdep_url,
            }

            print(voting_session.cdeppk, file= sys.stderr)

            votes = (
                models.db.session.query(
                    models.Vote,
                    models.Person,
                    models.MpGroup,
                )
                .filter(models.Vote.voting_session == voting_session)
                .join(models.Vote.mandate)
                .join(models.Mandate.person)
                .join(models.Mandate.group_memberships)
                .filter(
                    models.MpGroupMembership.interval
                    .contains(voting_session.date)
                )
                .join(models.MpGroupMembership.mp_group)
                .order_by(models.Person.name)
            )

            for (vote, person, mp_group) in votes:
                yield dict(cols_voting_session, **{
                    'nume': str(person),
                    'grup': mp_group.short_name,
                    'vot': VOTE_LABEL.get(vote.choice, "??"),
                })

    csv = csv_lines(
        ['data', 'titlu', 'cod cdep', 'link cdep', 'nume', 'grup', 'vot'],
        iter_rows(),
    )
    for line in csv:
        sys.stdout.write(line)
Пример #8
0
def export_questions(year):
    cols = ['data', 'numar', 'tip', 'titlu', 'nume', 'destinatar', 'scor']
    rows = (
        {
            'data': row['date'].isoformat(),
            'numar': row['number'],
            'tip': QUESTION_TYPE_LABEL[row['type']],
            'titlu': row['title'],
            'nume': row['name'],
            'destinatar': row['addressee'],
            'scor': int(row['local_score']),
        }
        for row in dal.get_all_questions(year=year)
    )
    data = buffer_on_disk(csv_lines(cols, rows))
    return csv_response(data)
Пример #9
0
def export_migrations():
    results = dal.get_group_migrations(
        start=parse_date(flask.request.args['start']),
        end=parse_date(flask.request.args.get('end', '9999-12-31')),
    )

    membership_list = [
        {
            'nume': row['name'],
            'data': row['date'].isoformat(),
            'partid_vechi': row['group_old'],
            'partid_nou': row['group_new'],
        }
        for row in results
    ]

    cols = ['nume', 'data', 'partid_vechi', 'partid_nou']
    return csv_response(csv_lines(cols, membership_list))
Пример #10
0
def export_group_membership():
    results = dal.get_group_membership(
        day=parse_date(flask.request.args.get('date')) or date.today()
    )

    membership_list = [
        {
            'nume': row['name'],
            'inceput': row['start'].isoformat(),
            'sfarsit': '' if row['end'] is None else row['end'].isoformat(),
            'partid': row['group'],
        }
        for row in results
    ]

    return csv_response(
        csv_lines(['nume', 'inceput', 'sfarsit', 'partid'], membership_list),
    )
Пример #11
0
def mandate_questions(mandate_id):
    mandate = (models.Mandate.query.filter_by(id=mandate_id).join(
        models.Mandate.person).first_or_404())
    addressee_count = defaultdict(int)
    questions = []
    for ask in mandate.asked.join(models.Question):
        q = ask.question
        questions.append({
            'id': q.id,
            'title': q.title,
            'date': q.date,
            'question_type': q.type,
            'addressee': q.addressee,
            'is_local_topic_flag': ask.get_meta('is_local_topic'),
            'score': ask.match.score or 0,
        })
        for name in q.addressee.split(';'):
            addressee_count[name.strip()] += 1

    if flask.request.args.get('format') == 'csv':
        cols = [
            'id', 'title', 'date', 'question_type', 'is_local_topic_flag',
            'score', 'addressee'
        ]
        return flask.Response(csv_lines(cols, questions), mimetype='text/csv')

    addressee_top = sorted(((n, name) for name, n in addressee_count.items()),
                           reverse=True)[:5]

    def sort_key(question):
        if question['is_local_topic_flag']:
            return 11.0
        else:
            return question['score'] or 0

    questions.sort(key=sort_key, reverse=True)
    return flask.render_template(
        'questions/mandate.html', **{
            'mandate': mandate,
            'questions': questions,
            'addressee_top': addressee_top,
        })
Пример #12
0
def mandate_questions(mandate_id):
    mandate = (models.Mandate.query
                     .filter_by(id=mandate_id)
                     .join(models.Mandate.person)
                     .first_or_404())
    addressee_count = defaultdict(int)
    questions = []
    for ask in mandate.asked.join(models.Question):
        q = ask.question
        questions.append({
            'id': q.id,
            'title': q.title,
            'date': q.date,
            'question_type': q.type,
            'addressee': q.addressee,
            'is_local_topic_flag': ask.get_meta('is_local_topic'),
            'score': ask.match.score or 0,
        })
        for name in q.addressee.split(';'):
            addressee_count[name.strip()] += 1

    if flask.request.args.get('format') == 'csv':
        cols = ['id', 'title', 'date', 'question_type', 'is_local_topic_flag',
                'score', 'addressee']
        return flask.Response(csv_lines(cols, questions),
                              mimetype='text/csv')

    addressee_top = sorted(((n, name) for name, n in addressee_count.items()),
                           reverse=True)[:5]

    def sort_key(question):
        if question['is_local_topic_flag']:
            return 11.0
        else:
            return question['score'] or 0
    questions.sort(key=sort_key, reverse=True)
    return flask.render_template('questions/mandate.html', **{
        'mandate': mandate,
        'questions': questions,
        'addressee_top': addressee_top,
    })
Пример #13
0
def question_dump():
    cols = ['name', 'legislature', 'date', 'title', 'score']
    ask_query = (
        models.Ask.query
        .options(
            joinedload('question'),
            joinedload('mandate'),
            joinedload('mandate.person'),
            joinedload('match_row'),
        )
    )
    def make_row(ask):
        score = ask.match.score
        return {
            'name': ask.mandate.person.name,
            'legislature': str(ask.mandate.year),
            'date': str(ask.question.date),
            'title': str(ask.question.title),
            'score': '' if score is None else str(score),
        }
    rows = (make_row(ask) for ask in ask_query.yield_per(10))
    data = buffer_on_disk(csv_lines(cols, rows))
    return flask.Response(data, mimetype='text/csv')