def test_map_values(self):
     """
     Test mapping a function to specific column values
     """
     t = TableFu(self.table)
     result = [s.lower() for s in t.values('Style')]
     self.assertEqual(result, t.map(str.lower, 'Style'))

 def test_sort_option_int(self):
     "Sorting the table by an int field, Number of Pages"
     t = TableFu(self.csv_file)
     pages = t.values('Number of Pages')
     pages = sorted(pages, reverse=True)
     t.sort('Number of Pages', reverse=True)
     self.assertEqual(t.values('Number of Pages'), pages)

 def test_row_map(self):
     """
     Test map a function to rows, or a subset of fields
     """
     t = TableFu(self.table)
     result = [s.lower() for s in t.values('Style')]
     self.assertEqual(result, t.map(lambda row: row['Style'].value.lower()))

 def test_limit_columns(self):
     "Column definitions are passed to rows"
     t = TableFu(self.csv_file)
     t.columns = ['Author', 'Style']
     self.assertEqual(
         str(t[0]),
         'Samuel Beckett, Modernism'
         )

 def test_facet(self):
     "Facet tables based on shared column values"
     t = TableFu(self.csv_file)
     tables = t.facet_by('Style')
     style_row = self.table[4]
     self.assertEqual(
         style_row,
         tables[2][0].cells
     )

    def test_cell_format(self):
        "Format a cell"
        t = TableFu(self.csv_file)
        t.formatting = {'Name': {'filter': 'link', 'args': ['URL']}}

        self.assertEqual(
            str(t[0]['Name']),
            '<a href="http://www.chrisamico.com" title="ChrisAmico.com">ChrisAmico.com</a>'
        )

 def testFacets(self):
     table = Table(self.yml)
     options = self.parsed['table']['column_options']
     url = "http://spreadsheets.google.com/pub?key=tcSL0eqrj3yb5d6ljak4Dcw&output=csv"
     response = urllib2.urlopen(url)
     tf = TableFu(response, **options)
     tables = tf.facet_by('State')
     for i, t in enumerate(tables):
         self.assertEqual(t.table, table.data[i].table)

 def test_transform_to_int(self):
     """
     Convert the Number of Pages field to integers
     """
     t = TableFu(self.csv_file)
     pages = t.values('Number of Pages')
     t.transform('Number of Pages', int)
     for s, i in zip(pages, t.values('Number of Pages')):
         self.assertEqual(int(s), i)

 def test_map_many_values(self):
     """
     Test mapping a function to multiple columns
     """
     t = TableFu(self.table)
     result = [
         [s.lower() for s in t.values(value)]
         for value in ['Best Book', 'Style']
     ]
     self.assertEqual(result, t.map(str.lower, 'Best Book', 'Style'))

 def test_sort(self):
     "Sort a table in place"
     t = TableFu(self.csv_file)
     self.table.pop(0)
     self.table.sort(key=lambda row: row[0])
     t.sort('Author')
     self.assertEqual(
         t[0].cells,
         self.table[0]
     )

 def _open(self):
     if self.url:
         f = urllib2.urlopen(self.url)
     elif self.filename:
         f = open(self.filename, 'rb')
     else: # there's neither a url nor a file
         raise TableError("You must specify a google_key, URL or local file containing CSV data")
     
     t = TableFu(f, **self.options.get('column_options', {}))
     if self.options.get('faceting', False):
         return t.facet_by(self.options['faceting']['facet_by'])
     return t

    def test_json(self):
        try:
            import json
        except ImportError:
            try:
                import simplejson as json
            except ImportError:
                return

        t = TableFu(self.csv_file)
        self.csv_file.seek(0)
        reader = csv.DictReader(self.csv_file)
        jsoned = json.dumps([row for row in reader])
        self.assertEqual(t.json(), jsoned)

 def test_from_url(self):
     if not os.getenv('TEST_REMOTE'):
         return True
     url = "http://spreadsheets.google.com/pub?key=thJa_BvqQuNdaFfFJMMII0Q&output=csv"
     t1 = TableFu.from_url(url)
     t2 = TableFu(urllib2.urlopen(url))
     self.assertEqual(t1.table, t2.table)

def csvviresult():
    global table
    # data = request.form['text']
    # table = TableFu.from_file('app/vi-csv.csv')
    table = TableFu.from_file('app/vi-csv.csv')
    # return render_template('vi-template.html', table=table)
    return render_template('vi-template.html', table=table)

 def test_transpose(self):
     t = TableFu(self.table)
     result = [
         ['Author', 'Samuel Beckett', 'James Joyce', 'Nicholson Baker', 'Vladimir Sorokin'],
         ['Best Book', 'Malone Muert', 'Ulysses', 'Mezannine', 'The Queue'],
         ['Number of Pages', '120', '644', '150', '263'],
         ['Style', 'Modernism', 'Modernism', 'Minimalism', 'Satire']
     ]
     
     transposed = t.transpose()
     self.assertEqual(transposed.table, result[1:])
     self.assertEqual(transposed.columns, [
         'Author',
         'Samuel Beckett',
         'James Joyce',
         'Nicholson Baker',
         'Vladimir Sorokin'
     ])

    def test_set_columns(self):
        arra = TableFu.from_file(self.filename)
        arra.columns = ["State", "County", "Urban Area"]

        tabled = Table(
            title="That Stimulus", added_by=self.user, file=File(self.file), columns=["State", "County", "Urban Area"]
        )
        tabled.save()

        self.assertEqual(arra.columns, tabled.data.columns)

 def data(self):
     """Return a TableFu instance with data for this model"""
     if hasattr(self, '_data') and self._data is not None:
         return self._data
     
     if self.file:
         # this gets wrapped in a with block for cleanliness
         d = TableFu.from_file(self.file.path)
     
     elif self.url:
         d = TableFu.from_url(self.url)
     
     else:
         return None
             
     if self.columns:
         d.columns = self.columns
     
     self._data = d
     return self._data

def virtualissueautomate():
    
    myDOIs = str(request.form["text"]).split('\r\n')
    
 
     # run python process
    createVI(myDOIs)

    global table
    # data = request.form['text']
    table = TableFu.from_file('vi-csv.csv')
    return render_template('vi-template.html', table=table, results=results)

def podcastupload():
    if request.method == 'POST':
    # Get the name of uploaded file
        file = request.files['file']
        # Check if the file is an allowed extension
        if file and allowed_file(file.filename):
            # Make the filename safe - remove unsupported characters
            filename = secure_filename(file.filename)
            # # Move the file from the temp folder to the upload folder
            file.save(os.path.join(app.config["UPLOAD_FOLDER"], filename))
            # Use tablefu to template out the uploaded CSV file
            global table
            table = TableFu.from_file('app/static/uploads/' + filename)
            return render_template('podcastresults.html', table=table)

def facet(starter, *facets):
    table = TableFu.from_file(starter)
    out_dir = os.path.dirname(starter)
    files = []
    for f in facets:
        try:
            tables = table.facet_by(f)
        except KeyError:
            sys.stderr.write('Bad column name: %s\n' % f)
            sys.stderr.write('Available columns: %s\n\n' % ', '.join(table.columns))
            continue

        for t in tables:
            out = open(os.path.join(out_dir, '%s.csv' % t.faceted_on), 'wb')
            out.write(t.csv().getvalue())
            out.close()
            files.append(out.name)
    
    return files