one-offs to generate a csv file from symposion Presentations and generate bitly links for them. very sloppy at the moment.

bitlyfy.py

#!/usr/bin/env python

import os, urllib

import bitly_api

import csvify
import secrets

class BitlyPresentations:
    def __init__(self, presentation_csv,
                 bitly_csv=None,
                 urlbase='http://conference.scipy.org/scipy2014/schedule/presentation'):

        self.urlbase = urlbase
        self.bitly = bitly_api.Connection(access_token=secrets.BITLY_ACCESS_TOKEN)

        self.presentations = self._snarf_presentations(presentation_csv)
        self.bitly_links = {}
        if bitly_csv is not None:
            self.bitly_links.update(self._snarf_bitly_links(bitly_csv))

    def shorten_all(self):
        """ shorten all presentations. do not update any existing links """
        for k, d in self.presentations.items():
            url = '{}/{}'.format(self.urlbase, d['presentation_id'])
            title = d['title']
            results = {}
            try:
                response = self.bitly.user_link_save(long_url=url, title=title, note=k)
                results[k] = {'status': 'ok', 'response': response}
                print 'OK', k, response
            except bitly_api.BitlyError as e:
                error_msg = "ERROR proposal_id: {} code: {} message: {}".format(k, e.code, e.message)
                print error_msg
                results[k] = {'status': error_msg, 'response': {}}
        return results

    def update_titles(self):
        for k, d in self.bitly_links.items():
            link = d.get('link', '')
            if 'link' == '' or k not in self.presentations:
                print 'ERROR not updating {}'.format(k)
                continue
            link = d['link']
            title = self.presentations[k]['title']
            results = {}
            try:
                response = self.bitly.user_link_edit(link, 'title', title=title)
                results[k] = {'status': 'ok', 'response': response}
                print 'OK', k, response
            except bitly_api.BitlyError as e:
                error_msg = "ERROR proposal_id: {} code: {} message: {}".format(k, e.code, e.message)
                print error_msg
                results[k] = {'status': error_msg, 'response': {}}

    def add_to_bundle(self, bundle_link='https://bitly.com/bundles/o_1uh69cuveq/4'):
        for k, d in self.bitly_links.items():
            link = d.get('link', '')
            try:
                response = self.bitly.bundle_link_add(bundle_link, link)
                print 'OK', k, response
            except bitly_api.BitlyError as e:
                error_msg = "ERROR proposal_id: {} code: {} message: {}".format(k, e.code, e.message)
                print error_msg


    def save_bitly_results(self, results, targetfile='results.csv'):
        """ save results to csv file, clobbering the file
        """
        with open(targetfile, 'w') as f:
            writer = csvify.UnicodeWriter(f)
            for k,d in results.items():
                response = d['response']
                row = [
                    k,
                    response.get('long_url', ''),
                    response.get('aggregate_link', ''),
                    response.get('link', ''),
                ]
                writer.writerow(row)

    def _snarf_bitly_links(self, csvfile):
        with open(csvfile) as f:
            bitly_reader = csvify.UnicodeReader(f)
            return dict((row[0], {'long_url': row[1], 'aggregate_link': row[2], 'link': row[3]})\
                        for row in bitly_reader)

    def _snarf_presentations(self, csvfile):
        with open(csvfile) as f:
            presentation_reader = csvify.UnicodeReader(f)
            return dict((row[0], {'presentation_id': row[1], 'title': row[2]}) for row in presentation_reader)


if __name__ == '__main__':
    bp = BitlyPresentations('presentations.csv', bitly_csv='results.csv')
    #bp = BitlyPresentations('test.csv', bitly_csv='testresults.csv', urlbase="http://example.com")
    #bp.update_titles()
    bp.add_to_bundle()
    #results = bp.shorten_all()
    #bp.save_bitly_results(results, 'testresults.csv')

csvify.py

#!/usr/bin/env python

import os, codecs, csv, cStringIO


# from https://docs.python.org/2/library/csv.html#examples
class UTF8Recoder:
    """
    Iterator that reads an encoded stream and reencodes the input to UTF-8
    """
    def __init__(self, f, encoding):
        self.reader = codecs.getreader(encoding)(f)

    def __iter__(self):
        return self

    def next(self):
        return self.reader.next().encode("utf-8")

class UnicodeReader:
    """
    A CSV reader which will iterate over lines in the CSV file "f",
    which is encoded in the given encoding.
    """
    def __init__(self, f, dialect=csv.excel, encoding="utf-8", **kwds):
        f = UTF8Recoder(f, encoding)
        self.reader = csv.reader(f, dialect=dialect, **kwds)

    def next(self):
        row = self.reader.next()
        return [unicode(s, "utf-8") for s in row]

    def __iter__(self):
        return self

class UnicodeWriter:
    """
    A CSV writer which will write rows to CSV file "f",
    which is encoded in the given encoding.
    """
    def __init__(self, f, dialect=csv.excel, encoding="utf-8", **kwds):
        # Redirect output to a queue
        self.queue = cStringIO.StringIO()
        self.writer = csv.writer(self.queue, dialect=dialect, **kwds)
        self.stream = f
        self.encoder = codecs.getincrementalencoder(encoding)()

    def writerow(self, row):
        self.writer.writerow([s.encode("utf-8") for s in row])
        # Fetch UTF-8 output from the queue ...
        data = self.queue.getvalue()
        data = data.decode("utf-8")
        # ... and reencode it into the target encoding
        data = self.encoder.encode(data)
        # write to the target stream
        self.stream.write(data)
        # empty queue
        self.queue.truncate(0)

    def writerows(self, rows):
        for row in rows:
            self.writerow(row)


def csvify(presentations):
    with open('presentations.csv', 'w') as fh:
        writer = UnicodeWriter(fh)
        for p in presentations:
            writer.writerow([str(p.proposal.id), str(p.id), p.title])


if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "scipy2014.settings")
    from symposion.schedule.models import Presentation

    presentations = Presentation.objects.order_by('proposal_base')
    csvify(presentations)

lanyardify.py

#!/usr/bin/env python

import os, codecs, csv, cStringIO, json


def schedule_dict(bitly_links={}):
    """ json in lanyard format """
    presentations = Presentation.objects.filter(cancelled=False)
    sessions = []
    for p in presentations:
        sessions.append(to_session(p, bitly_links=bitly_links))
    return sessions


# based on https://docs.google.com/document/d/1aT_mIJ7Q-eawamGs_9HrBZL_Lfa0dBohXhc1SpfYSj0/pub?embedded=true
def to_session(presentation, bitly_links={}):
    # get the room of a presentation
    # from slot to slotroom to room
    slot = presentation.slot
    slotroom = SlotRoom.objects.get(slot=slot)
    room = slotroom.room
    year = slot.day.date.strftime('%Y-%m-%d')

    d = bitly_links.get(str(presentation.proposal.id), {})
    url = d.get('link', '')

    speakers = []
    for s in presentation.speakers():
        speakers.append(to_speaker(s))

    return {
        'crowdsource_ref': presentation.proposal.id,
        'title': presentation.title,
        'abstract': presentation.description.raw, # not LML.
        'url': url,
        'start_time': '{} {}'.format(year, slot.start.strftime('%H:%M')),
        'end_time': '{} {}'.format(year, slot.end.strftime('%H:%M')),
        'space_name': room.name,
        'venue': 'vd', # default to AT&T conference center
        'speakers': speakers, # list of speakers
    }
    # http://lanyrd.com/venues/austin/vd/ att
    # http://lanyrd.com/venues/austin/vdqym/ enthought
    # http://lanyrd.com/venues/austin/vdqyp/ scholtz

def to_speaker(speaker):
    return {
        'crowdsource_ref': speaker.user.id,
        'name': speaker.name,
        #'role': '',
        'bio': speaker.biography.raw, # not LML
    }


# from https://docs.python.org/2/library/csv.html#examples
class UTF8Recoder:
    """
    Iterator that reads an encoded stream and reencodes the input to UTF-8
    """
    def __init__(self, f, encoding):
        self.reader = codecs.getreader(encoding)(f)

    def __iter__(self):
        return self

    def next(self):
        return self.reader.next().encode("utf-8")

class UnicodeReader:
    """
    A CSV reader which will iterate over lines in the CSV file "f",
    which is encoded in the given encoding.
    """
    def __init__(self, f, dialect=csv.excel, encoding="utf-8", **kwds):
        f = UTF8Recoder(f, encoding)
        self.reader = csv.reader(f, dialect=dialect, **kwds)

    def next(self):
        row = self.reader.next()
        return [unicode(s, "utf-8") for s in row]

    def __iter__(self):
        return self

def snarf_bitly_links(csvfile):
    with open(csvfile) as f:
        bitly_reader = UnicodeReader(f)
        return dict((row[0], {'long_url': row[1], 'aggregate_link': row[2], 'link': row[3]})\
                for row in bitly_reader)


if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "scipy2014.settings")
    from symposion.schedule.models import Presentation, SlotRoom, Slot, Room
    from symposion.speakers.models import Speaker

    bitly_links = snarf_bitly_links('results.csv')
    d = schedule_dict(bitly_links=bitly_links)
    with open('lanyard.json', 'w') as f:
        json.dump(d, f, indent=2)

presentations.csv

results.csv