pip install agate

git clone git://github.com/wireservice/agate.git
cd agate
mkvirtualenv agate
pip install -e .[test]

column_names = ['letter', 'number']
column_types = [agate.Text(), agate.Number()]
rows = [


    ('a', 1),


    ('b', 2),


    ('c', None)
]
table = agate.Table(rows, column_names, column_types)

rows = [


    dict(letter='a', number=1),


    dict(letter='b', number=2),


    dict(letter='c', number=None)
]
table = agate.Table.from_object(rows)

table = agate.Table.from_csv('filename.csv')

specified_types = {


    'column_name_one': agate.Text(),


    'column_name_two': agate.Number()
}
table = agate.Table.from_csv('filename.csv', column_types=specified_types)

tester = agate.TypeTester(limit=100)
table = agate.Table.from_csv('filename.csv', column_types=tester)

text_type = agate.Text()
number_type = agate.Number()
column_names = ['city', 'area', 'population']
column_types = [text_type, number_type, number_type]
table = agate.Table.from_csv('population.csv', column_names, column_types)

table = agate.Table.from_csv('population.csv', column_names, column_types, header=False)

table = agate.Table.from_csv('census.csv', encoding='latin1')

table = agate.Table.from_csv('filename.csv', delimiter=';')

table = agate.Table.from_csv('filename.csv', delimiter='\t')

table = agate.Table.from_json('filename.json')

table = agate.Table.from_json('filename.json', newline=True)

import agatesql
table = agate.Table.from_sql('postgresql:///database', 'input_table')

import agateexcel
table = agate.Table.from_xls('test.xls', sheet='data')
table2 = agate.Table.from_xlsx('test.xlsx', sheet='data')

import agatedbf
table = agate.Table.from_dbf('test.dbf')

import agateremote
table = agate.Table.from_url('https://raw.githubusercontent.com/wireservice/agate/master/examples/test.csv')

archive = agateremote.Archive('https://github.com/vincentarelbundock/Rdatasets/raw/master/csv/')
table = archive.get_table('sandwich/PublicSchools.csv')

table.to_csv('filename.csv')

table.to_json('filename.json')

table.to_json('filename.json', newline=True)

import agatesql
table.to_sql('postgresql:///database', 'output_table')

include_columns = ['column_name_one', 'column_name_two']
new_table = table.select(include_columns)

exclude_columns = ['column_name_one', 'column_name_two']
new_table = table.exclude(exclude_columns)

import re
new_table = table.where(lambda row: re.match('^C', str(row['state'])))

new_table = table.where(lambda row: not re.match('\d{3}-\d{3}-\d{4}', str(row['phone'])))

from fnmatch import fnmatch
new_table = table.where(lambda row: fnmatch('C*', row['state']))

new_table = table.where(lambda row: 100000 < row['income'] < 200000)

import datetime
new_table = table.where(lambda row: datetime.datetime(2015, 6, 1) <= row['date'] <= datetime.datetime(2015, 8, 31))

new_table = table.where(lambda row: 6 <= row['date'].month <= 8)

percentiles = table.aggregate(agate.Percentiles('salary'))
top_ten_percent = table.where(lambda r: r['salary'] >= percentiles[90])

import random
randomized = table.order_by(lambda row: random.random())
sampled = table.limit(10)

sampled = table.limit(step=10)

columns = ('value',)
rows = ([1],[2],[2],[5])
new_table = agate.Table(rows, columns)
new_table.columns['value'].values_distinct()
# or
new_table.distinct('value').columns['value'].values()
(Decimal('1'), Decimal('2'), Decimal('5'))

new_table = table.order_by('last_name')

new_table = table.order_by('cost')

new_table = table.order_by('birth_date')

new_table = table.order_by('birth_date', reverse=True)

new_table = table.order_by(lambda row: (row['last_name'], row['first_name']))

import random
new_table = table.order_by(lambda row: random.random())

family = table.where(lambda r: r['last_name'] == 'Groskopf')

from Levenshtein import distance
fuzzy_family = table.where(lambda r: distance(r['last_name'], 'Groskopf') <= 2)

import fuzzy
dmetaphone = fuzzy.DMetaphone(4)
phonetic_search = dmetaphone('Catherine')
def phonetic_match(r):


    return any(x in dmetaphone(r['first_name']) for x in phonetic_search)
phonetic_family = table.where(lambda r: phonetic_match(r))

# Convert column names to unique slugs
table.rename(slug_columns=True)
# Convert row names to unique slugs
table.rename(slug_rows=True)
# Convert both column and row names to unique slugs
table.rename(slug_columns=True, slug_rows=True)

# Convert the values in column 'title' to slugs
new_table = table.compute([


    ('title-slug', agate.Slug('title'))
])
# Convert the values in column 'title' to unique slugs
new_table = table.compute([


    ('title-slug', agate.Slug('title', ensure_unique=True))
])

table.aggregate(agate.Sum('salary'))
table.aggregate(agate.Min('salary'))
table.aggregate(agate.Max('salary'))
table.aggregate(agate.Mean('salary'))
table.aggregate(agate.Median('salary'))
table.aggregate(agate.Mode('salary'))
table.aggregate(agate.Variance('salary'))
table.aggregate(agate.StDev('salary'))
table.aggregate(agate.MAD('salary'))

table.aggregate([


    ('salary_min', agate.Min('salary')),


    ('salary_ave', agate.Mean('salary')),


    ('salary_max', agate.Max('salary')),
])

doctors = patients.group_by('doctor')
patient_ages = doctors.aggregate([


    ('patient_count', agate.Count()),


    ('age_mean', agate.Mean('age')),


    ('age_median', agate.Median('age'))
])

doctors_by_state = patients.group_by("state").group_by('doctor')

# Counts of a single column's values
table.pivot('doctor')
# Counts of all combinations of more than one column's values
table.pivot(['doctor', 'hospital'])

# Percents of a single column's values
table.pivot('doctor', computation=agate.Percent('Count'))
# Percents of all combinations of more than one column's values
table.pivot(['doctor', 'hospital'], computation=agate.Percent('Count'))

import agatestats
outliers = table.stdev_outliers('salary', deviations=3, reject=False)

not_outliers = table.stdev_outliers('salary', deviations=3, reject=True)

outliers = table.mad_outliers('salary', deviations=3, reject=False)

# Create a custom summary aggregation with agate.Summary
# Input a column name, a return data type and a function to apply on the column
count_millionaires = agate.Summary('salary', agate.Number(), lambda r: sum(salary > 1000000 for salary in r.values()))
table.aggregate([


    count_millionaires
])

new_table = table.compute([


    ('2000_change', agate.Change('2000', '2001')),


    ('2001_change', agate.Change('2001', '2002')),


    ('2002_change', agate.Change('2002', '2003'))
])

computations = []
for year in range(2000, 2010):


    change = agate.Change(year, year + 1)


    computations.append(('%i_change' % year, change))
new_table = table.compute(computations)

columns = ('value',)
rows = ([1],[2],[2],[5])
new_table = agate.Table(rows, columns)
new_table = new_table.compute([


    ('percent', agate.Percent('value'))
])
new_table.print_table()
| value | percent |
| ----- | ------- |
|     1 |      10 |
|     2 |      20 |
|     2 |      20 |
|     5 |      50 |

new_table = new_table.compute([


    ('percent', agate.Percent('value', 5))
])
new_table.print_table()
| value | percent |
| ----- | ------- |
|     1 |      20 |
|     2 |      40 |
|     2 |      40 |
|     5 |     100 |

computations = []
for year in range(2000, 2010):


    change = agate.PercentChange(year, year + 1)


    computations.append(('%i_change' % year, change))
new_table = table.compute(computations)

computations = []
for year in range(2000, 2010):


    change = agate.Change(2000, year + 1)


    computations.append(('%i_change' % year, change))
new_table = table.compute(computations)

from decimal import Decimal
number_type = agate.Number()
def round_price(row):


    return row['price'].quantize(Decimal('0.01'))
new_table = table.compute([


    ('price_rounded', agate.Formula(number_type, round_price))
])

new_table = table.compute([


    ('age_at_death', agate.Change('born', 'died'))
])

import agate
from Levenshtein import distance
class LevenshteinDistance(agate.Computation):


    """


    Computes Levenshtein edit distance between the column and a given string.


    """


    def __init__(self, column_name, compare_string):


        self._column_name = column_name


        self._compare_string = compare_string


    def get_computed_data_type(self, table):


        """


        The return value is a numerical distance.


        """


        return agate.Number()


    def validate(self, table):


        """


        Verify the column is text.


        """


        column = table.columns[self._column_name]


        if not isinstance(column.data_type, agate.Text):


            raise agate.DataTypeError('Can only be applied to Text data.')


    def run(self, table):


        """


        Find the distance, returning null when the input column was null.


        """


        new_column = []


        for row in table.rows:


          val = row[self._column_name]


          if val is None:


              new_column.append(None)


          else:


              new_column.append(distance(val, self._compare_string))


        return new_column

new_table = table.compute([


    ('distance', LevenshteinDistance('column_name', 'string to compare'))
])

class USATodayDiversityIndex(agate.Computation):


    def get_computed_data_type(self, table):


        return agate.Number()


    def run(self, table):


        new_column = []


        for row in table.rows:


          race_squares = 0


          for race in ['white', 'black', 'asian', 'american_indian', 'pacific_islander']:


              race_squares += (row[race] / row['population']) ** 2


          hispanic_squares = (row['hispanic'] / row['population']) ** 2


          hispanic_squares += (1 - (row['hispanic'] / row['population'])) ** 2


          new_column.append((1 - (race_squares * hispanic_squares)) * 100)


        return new_column

with_index = table.compute([


    ('diversity_index', USATodayDiversityIndex())
])

class SimpleMovingAverage(agate.Computation):


    """


    Computes the simple moving average of a column over some interval.


    """


    def __init__(self, column_name, interval):


        self._column_name = column_name


        self._interval = interval


    def get_computed_data_type(self, table):


        """


        The return value is a numerical average.


        """


        return agate.Number()


    def validate(self, table):


        """


        Verify the column is numerical.


        """


        column = table.columns[self._column_name]


        if not isinstance(column.data_type, agate.Number):


            raise agate.DataTypeError('Can only be applied to Number data.')


    def run(self, table):


        new_column = []


        for i, row in enumerate(table.rows):


            if i < self._interval:


                new_column.append(None)


            else:


                values = tuple(r[self._column_name] for r in table.rows[i - self._interval:i])


                if None in values:


                    new_column.append(None)


                else:


                    new_column.append(sum(values) / self._interval)


        return new_column

with_average = table.compute([


    ('six_month_moving_average', SimpleMovingAverage('price', 6))
])

date_type = agate.Date('%d-%m-%y')

date_type = agate.Date('%m/%d/%Y 00:00')

datetime_type = agate.DateTime('%Y-%m-%d %H:%M:%S%z')

from zoneinfo import ZoneInfo
eastern = ZoneInfo('US/Eastern')
datetime_type = agate.DateTime(timezone=eastern)

from zoneinfo import ZoneInfo
us_eastern = ZoneInfo('US/Eastern')
datetime_type = agate.DateTime(timezone=us_eastern)
column_names = ['what', 'when']
column_types = [text_type, datetime_type]
table = agate.Table.from_csv('events.csv', columns)
rome = ZoneInfo('Europe/Rome')
timezone_shifter = agate.Formula(lambda r: r['when'].astimezone(rome))
table = agate.Table.compute([


    ('when_in_rome', timezone_shifter)
])

SELECT state, total FROM table;

new_table = table.select(['state', 'total'])

SELECT * FROM table WHERE LOWER(state) = 'california';

new_table = table.where(lambda row: row['state'].lower() == 'california')

SELECT * FROM table ORDER BY total DESC;

new_table = table.order_by(lambda row: row['total'], reverse=True)

SELECT DISTINCT ON (state) * FROM table;

new_table = table.distinct('state')

SELECT * FROM patient, doctor WHERE patient.doctor = doctor.id;
SELECT * FROM patient INNER JOIN doctor ON (patient.doctor = doctor.id);

joined = patients.join(doctors, 'doctor', 'id', inner=True)

SELECT * FROM patient LEFT OUTER JOIN doctor ON (patient.doctor = doctor.id);

joined = patients.join(doctors, 'doctor', 'id')

SELECT * FROM patient FULL OUTER JOIN doctor ON (patient.doctor = doctor.id);

joined = patients.join(doctors, 'doctor', 'id', full_outer=True)

doctors = patients.group_by('doctor')

doctors_by_state = patients.group_by('state').group_by('doctor')

doctors = patients.group_by('doctor')
popular_doctors = doctors.having([


    ('patient_count', Count())
], lambda t: t['patient_count'] > 100)

doctors = patients.group_by('doctor')
popular_doctors = doctors.having([


    ('patient_count', Count()),


    ('average_stars', Average('stars'))
], lambda t: t['patient_count'] > 100 and t['average_stars'] >= 3)

SELECT state, total FROM table WHERE LOWER(state) = 'california' ORDER BY total DESC;

new_table = table \


    .select(['state', 'total']) \


    .where(lambda row: row['state'].lower() == 'california') \


    .order_by('total', reverse=True)

SELECT mean(age), median(age) FROM patients GROUP BY doctor;

doctors = patients.group_by('doctor')
patient_ages = doctors.aggregate([


    ('patient_count', agate.Count()),


    ('age_mean', agate.Mean('age')),


    ('age_median', agate.Median('age'))
])

=($A1 + $B1) / $C1

def f(row):


    return (row['a'] + row['b']) / row['c']
new_table = table.compute([


    ('new_column', agate.Formula(agate.Number(), f))
])

number_type = agate.Number()
def five_year_total(row):


    columns = ('2009', '2010', '2011', '2012', '2013')


    return sum(tuple(row[c] for c in columns)]
formula = agate.Formula(number_type, five_year_total)
new_table = table.compute([


    ('five_year_total', formula)
])

new_table = table.compute([


    ('name_stripped', agate.Formula(text_type, lambda r: r['name'].strip()))
])

new_table = table.compute([


    ('full_name', agate.Formula(text_type, lambda r: '%(first_name)s %(middle_name)s %(last_name)s' % r))
])

new_table = table.compute([


    ('mvp_candidate', agate.Formula(boolean_type, lambda r: row['batting_average'] > 0.3))
])

new_table = mvp_table.join(states, 'state_abbr')

states = {


    'AL': 'Alabama',


    'AK': 'Alaska',


    'AZ': 'Arizona',


    ...
}
new_table = table.compute([


    ('mvp_candidate', agate.Formula(text_type, lambda r: states[row['state_abbr']]))
])

jobs_by_state_and_year = employees.pivot('state', 'year')

jobs = employees.group_by('job_title')
summary = jobs.aggregate([


    ('employee_count', agate.Count()),


    ('salary_mean', agate.Mean('salary')),


    ('salary_median', agate.Median('salary'))
])

selected <- data[c("last_name", "first_name", "age")]
excluded <- data[!c("last_name", "first_name", "age")]

selected = table.select(['last_name', 'first_name', 'age'])
excluded = table.exclude(['last_name', 'first_name', 'age'])

newdata <- subset(data, age >= 20 | age < 10)

new_table = table.where(lambda row: row['age'] >= 20 or row['age'] < 10)

newdata <- employees[order(last_name),]

new_table = employees.order_by('last_name')

joined <- merge(employees, states, by="usps")

joined = employees.join(states, 'usps')

merged <- rbind(first_year, second_year)

merged = agate.Table.merge(first_year, second_year)

aggregates = aggregate(employees$salary, list(job = employees$job), mean)

jobs = employees.group_by('job')
aggregates = jobs.aggregate([


    ('mean', agate.Mean('salary'))
])

melt(employees, id=c("last_name", "first_name"))

employees.normalize(['last_name', 'first_name'])

melted = melt(employees, id=c("name"))
casted = cast(melted, name~variable, mean)

normalized = employees.normalize(['name'])
denormalized = normalized.denormalize('name')

new_table = table.where(lambda row: row['state'] == 'Texas')

new_table = table.where(lambda row: not (row['state'] == 'Texas'))

row = table.find(lambda row: row['state'].startswith('T'))

true_or_false = table.aggregate(Any('salaries', lambda d: d > 100000))

true_or_false = table.aggregate(All('salaries', lambda d: d > 100000))

key = 'year'
expected_values = (1997, 1998, 1999, 2000, 2001, 2002, 2003)
# Your default row should specify column values not in `key`
default_row = (0, 0)
new_table = table.homogenize(key, expected_values, default_row)

key = 'year'
expected_values = (1997, 1998, 1999, 2000, 2001, 2002, 2003)
# If default row is a function, it should return a full row
def default_row(missing_value):


  return (missing_value, missing_value-1997, missing_value-1997)
new_table = table.homogenize(key, expected_values, default_row)

table = Table(rows, column_names = ['a', 'b', 'c'])
new_table = table.rename(column_names = ['one', 'two', 'three'])
# or
new_table = table.rename(column_names = {'a': 'one', 'b': 'two', 'c': 'three'})

new_table = table.select(['3rd_column_name', '1st_column_name', '2nd_column_name'])

transformed = table.pivot('race')

transformed = table.pivot(['race', 'gender'])

transformed = table.pivot('race', 'gender')

transformed = table.pivot('race', 'gender', aggregation=agate.Sum('age'))

transformed = table.pivot('race', 'gender', aggregation=agate.Sum('age'), computation=agate.Percent('sum'))

transformed = table.denormalize('name', 'property', 'value')

transformed = table.normalize('name', ['gender', 'race', 'age'])

dutch_numbers = agate.Number(locale='nl_NL')
column_names = ['city', 'population']
column_types = [text_type, dutch_numbers]
table = agate.Table.from_csv('dutch_cities.csv', columns)

new_table = table.compute([


    ('rank', agate.Rank('value'))
])

new_table = table.compute([


    ('rank', agate.Rank('value', reverse=True))
])

new_table = table.compute([


    ('rank2014', agate.Rank('value2014')),


    ('rank2015', agate.Rank('value2015'))
])
new_table2 = new_table.compute([


    ('rank_change', agate.Change('rank2014', 'rank2015'))
])

new_table = table.compute([


    ('percentile_rank', agate.PercentileRank('value'))
])

table.limit(10).print_bars('State Name', 'TOTAL', width=80)

State Name         TOTAL
ALABAMA           19,582 ▓░░░░░░░░░░░░░
ALASKA             2,705 ▓░░
ARIZONA           46,743 ▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
ARKANSAS           7,932 ▓░░░░░
CALIFORNIA        76,639 ▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
COLORADO          21,485 ▓░░░░░░░░░░░░░░░
CONNECTICUT        4,350 ▓░░░
DELAWARE           1,904 ▓░
DIST. OF COLUMBIA  2,185 ▓░
FLORIDA           59,519 ▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░


                         +-------------+------------+------------+-------------+


                         0          20,000       40,000       60,000      80,000

table.bins('TOTAL', start=0, end=100000).print_bars('TOTAL', width=80)

TOTAL              Count
[0 - 10,000)          30 ▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
[10,000 - 20,000)     12 ▓░░░░░░░░░░░░░░░░░░░░░░
[20,000 - 30,000)      7 ▓░░░░░░░░░░░░░
[30,000 - 40,000)      1 ▓░░
[40,000 - 50,000)      2 ▓░░░░
[50,000 - 60,000)      1 ▓░░
[60,000 - 70,000)      1 ▓░░
[70,000 - 80,000)      1 ▓░░
[80,000 - 90,000)      0 ▓
[90,000 - 100,000]     0 ▓


                         +-------------+------------+------------+-------------+


                         0.0          7.5         15.0         22.5         30.0

table.limit(10).bar_chart('State Name', 'TOTAL', 'docs/images/bar_chart.svg')

table.limit(10).column_chart('State Name', 'TOTAL', 'docs/images/column_chart.svg')

by_year_exonerated = table.group_by('exonerated')
counts = by_year_exonerated.aggregate([


    ('count', agate.Count())
])
counts.order_by('exonerated').line_chart('exonerated', 'count', 'docs/images/line_chart.svg')

table.scatterplot('exonerated', 'age', 'docs/images/dots_chart.svg')

top_crimes = table.group_by('crime').having([


    ('count', agate.Count())
], lambda t: t['count'] > 100)
by_year = top_crimes.group_by('exonerated')
counts = by_year.aggregate([


    ('count', agate.Count())
])
by_crime = counts.group_by('crime')
by_crime.order_by('exonerated').line_chart('exonerated', 'count', 'docs/images/lattice.svg')

import pylab
pylab.plot(table.columns['homeruns'], table.columns['wins'])
pylab.xlabel('Homeruns')
pylab.ylabel('Wins')
pylab.title('How homeruns correlate to wins')
pylab.show()

import agatelookup
join_year_cpi = table.lookup('year', 'cpi')

cpi_2015 = Decimal(216.909)
def cpi_adjust_2015(row):


    return (row['cost'] * (cpi_2015 / row['cpi'])).quantize(Decimal('0.01'))
cost_2015 = join_year_cpi.compute([


    ('cost_2015', agate.Formula(agate.Number(), cpi_adjust_2015))
])

import agate
import agatesql
# After calling patch the from_sql and to_sql methods are now part of the Table class
table = agate.Table.from_sql('postgresql:///database', 'input_table')
table.to_sql('postgresql:///database', 'output_table')

import agate
def new_method(self):


    print('I do something to a Table when you call me.')
agate.Table.new_method = new_method

def new_class_method(cls):


    print('I make Tables when you call me.')
agate.Table.new_method = classmethod(new_method)

>>> import agate
>>> import myextension
>>> table = agate.Table(rows, column_names, column_types)
>>> table.new_method()
'I do something to a Table when you call me.'
>>> agate.Table.new_class_method()
'I make Tables when you call me.'

Parameters

property column_types

An tuple DataType <#agate.DataType> instances.

property column_names

An tuple of strings.

property row_names

An tuple of strings, if this table has row names.

If this table does not have row names, then None.

property columns

A MappedSequence <#agate.MappedSequence> with column names for keys and Column <#agate.Column> instances for values.

property rows

A MappedSeqeuence with row names for keys (if specified) and Row <#agate.Row> instances for values.

print_csv(**kwargs)

Print this table as a CSV.

This is the same as passing sys.stdout to Table.to_csv().

kwargs will be passed on to Table.to_csv().

print_json(**kwargs)

Print this table as JSON.

This is the same as passing sys.stdout to Table.to_json().

kwargs will be passed on to Table.to_json().

aggregate(aggregations)

Apply one or more Aggregation <#agate.Aggregation> instances to this table.

bar_chart(label=0, value=1, path=None, width=None, height=None)

Render a bar chart using leather.Chart.

bins(column_name, count=10, start=None, end=None)

Generates (approximately) evenly sized bins for the values in a column. Bins may not be perfectly even if the spread of the data does not divide evenly, but all values will always be included in some bin.

The resulting table will have two columns. The first will have the same name as the specified column, but will be type Text <#agate.Text>. The second will be named count and will be of type Number <#agate.Number>.

column_chart(label=0, value=1, path=None, width=None, height=None)

Render a column chart using leather.Chart.

compute(computations, replace=False)

Create a new table by applying one or more Computation <#agate.Computation> instances to each row.

denormalize(key=None, property_column='property', value_column='value', default_value=<object object>, column_types=None)

Create a new table with row values converted into columns.

For example:

name	property	value
Jane	gender	female
Jane	race	black
Jane	age	24
...	...	...

Can be denormalized so that each unique value in field becomes a column with value used for its values.

name	gender	race	age
Jane	female	black	24
Jack	male	white	35
Joe	male	black	28

If one or more keys are specified then the resulting table will automatically have row_names set to those keys.

This is the opposite of Table.normalize().

distinct(key=None)

Create a new table with only unique rows.

exclude(key)

Create a new table without the specified columns.

find(test)

Find the first row that passes a test.

classmethod from_csv(path, column_names=None, column_types=None, row_names=None, skip_lines=0, header=True, sniff_limit=0, encoding='utf-8', row_limit=None, **kwargs)

Create a new table from a CSV.

This method uses agate's builtin CSV reader, which supplies encoding support for both Python 2 and Python 3.

kwargs will be passed through to the CSV reader.

classmethod from_fixed(path, schema_path, column_names=<object object>, column_types=None, row_names=None, encoding='utf-8', schema_encoding='utf-8')

Create a new table from a fixed-width file and a CSV schema.

Schemas must be in the "ffs" format. There is a repository of such schemas maintained at wireservice/ffs <https://github.com/wireservice/ffs>.

classmethod from_json(path, row_names=None, key=None, newline=False, column_types=None, encoding='utf-8', **kwargs)

Create a new table from a JSON file.

Once the JSON has been deseralized, the resulting Python object is passed to Table.from_object().

If the file contains a top-level dictionary you may specify what property contains the row list using the key parameter.

kwargs will be passed through to json.load().

classmethod from_object(obj, row_names=None, column_types=None)

Create a new table from a Python object.

The object should be a list containing a dictionary for each "row". Nested objects or lists will also be parsed. For example, this object:

{


    'one': {


        'a': 1,


        'b': 2,


        'c': 3


    },


    'two': [4, 5, 6],


    'three': 'd'
}

Would generate these columns and values:

{


    'one/a': 1,


    'one/b': 2,


    'one/c': 3,


    'two.0': 4,


    'two.1': 5,


    'two.2': 6,


    'three': 'd'
}

Column names and types will be inferred from the data.

Not all rows are required to have the same keys. Missing elements will be filled in with null values.

Keys containing a slash (/) can collide with other keys. For example:

{


    'a/b': 2,


    'a': {


        'b': False


    }
}

Would generate:

{


    'a/b': false
}

group_by(key, key_name=None, key_type=None)

Create a TableSet <#agate.TableSet> with a table for each unique key.

Note that group names will always be coerced to a string, regardless of the format of the input column.

homogenize(key, compare_values, default_row=None)

Fill in missing rows in a series.

This can be used, for instance, to add rows for missing years in a time series.

Missing rows are found by comparing the values in the key columns with those provided as compare_values.

Values not found in the table will be used to generate new rows with the given default_row.

default_row should be an array of values or an array-generating function. If not specified, the new rows will have None in columns all columns not specified in key.

If default_row is an array of values, its length should be row length minus the number of column names provided in the key.

If it is an array-generating function, the function should take an array of missing values for each new row and output a full row including those values.

join(right_table, left_key=None, right_key=None, inner=False, full_outer=False, require_match=False, columns=None)

Create a new table by joining two table's on common values. This method implements most varieties of SQL join, in addition to some unique features.

If left_key and right_key are both None then this method will perform a "sequential join", which is to say it will join on row number. The inner and full_outer arguments will determine whether dangling left-hand and right-hand rows are included, respectively.

If left_key is specified, then a "left outer join" will be performed. This will combine columns from the right_table anywhere that left_key and right_key are equal. Unmatched rows from the left table will be included with the right-hand columns set to None.

If inner is True then an "inner join" will be performed. Unmatched rows from either table will be left out.

If full_outer is True then a "full outer join" will be performed. Unmatched rows from both tables will be included, with the columns in the other table set to None.

In all cases, if right_key is None then it left_key will be used for both tables.

If left_key and right_key are column names, the right-hand identifier column will not be included in the output table.

If require_match is True unmatched rows will raise an exception. This is like an "inner join" except any row that doesn't have a match will raise an exception instead of being dropped. This is useful for enforcing expectations about datasets that should match.

Column names from the right table which also exist in this table will be suffixed "2" in the new table.

A subset of columns from the right-hand table can be included in the joined table using the columns argument.

limit(start_or_stop=None, stop=None, step=None)

Create a new table with fewer rows.

See also: Python's builtin slice().

line_chart(x=0, y=1, path=None, width=None, height=None)

Render a line chart using leather.Chart.

classmethod merge(tables, row_names=None, column_names=None)

Create a new table from a sequence of similar tables.

This method will not carry over row names from the merged tables, but new row names can be specified with the row_names argument.

It is possible to limit the columns included in the new Table with column_names argument. For example, to only include columns from a specific table, set column_names equal to table.column_names.

normalize(key, properties, property_column='property', value_column='value', column_types=None)

Create a new table with columns converted into rows values.

For example:

name	gender	race	age
Jane	female	black	24
Jack	male	white	35
Joe	male	black	28

can be normalized on columns 'gender', 'race' and 'age':

name	property	value
Jane	gender	female
Jane	race	black
Jane	age	24
...	...	...

This is the opposite of Table.denormalize().

order_by(key, reverse=False)

Create a new table that is sorted.

pivot(key=None, pivot=None, aggregation=None, computation=None, default_value=<object object>, key_name=None)

Create a new table by grouping the data, aggregating those groups, applying a computation, and then organizing the groups into new rows and columns.

This is sometimes called a "crosstab".

name	race	gender
Joe	white	male
Jane	black	female
Josh	black	male
Jim	asian	female

This table can be pivoted with key equal to "race" and columns equal to "gender". The default aggregation is Count <#agate.Count>. This would result in the following table.

race	male	female
white	1	0
black	1	1
asian	0	1

If one or more keys are specified then the resulting table will automatically have row_names set to those keys.

See also the related method Table.denormalize().

print_bars(label_column_name='group', value_column_name='Count', domain=None, width=120, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, printable=False)

Print a text-based bar chart based on this table.

print_html(max_rows=20, max_columns=6, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, max_column_width=20, locale=None, max_precision=3)

Print an HTML version of this table.

print_structure(output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, max_rows=None)

Print this table's column names and types as a plain-text table.

print_table(max_rows=20, max_columns=6, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, max_column_width=20, locale=None, max_precision=3)

Print a text-based view of the data in this table.

The output of this method is GitHub Flavored Markdown (GFM) compatible.

rename(column_names=None, row_names=None, slug_columns=False, slug_rows=False, **kwargs)

Create a copy of this table with different column names or row names.

By enabling slug_columns or slug_rows and not specifying new names you may slugify the table's existing names.

kwargs will be passed to the slugify method in python-slugify. See: <https://github.com/un33k/python-slugify>

scatterplot(x=0, y=1, path=None, width=None, height=None)

Render a scatterplot using leather.Chart.

select(key)

Create a new table with only the specified columns.

to_csv(path, **kwargs)

Write this table to a CSV. This method uses agate's builtin CSV writer, which supports unicode on both Python 2 and Python 3.

kwargs will be passed through to the CSV writer.

The lineterminator defaults to the newline character (LF, \n).

to_json(path, key=None, newline=False, indent=None, **kwargs)

Write this table to a JSON file or file-like object.

kwargs will be passed through to the JSON encoder.

where(test)

Create a new Table with only those rows that pass a test.

Parameters

property key_name

Get the name of the key this TableSet is grouped by. (If created using Table.group_by() <#agate.Table.group_by> then this is the original column name.)

property key_type

Get the DataType <#agate.DataType> this TableSet is grouped by. (If created using Table.group_by() <#agate.Table.group_by> then this is the original column type.)

property column_types

Get an ordered list of this TableSet's column types.

property column_names

Get an ordered list of this TableSet's column names.

aggregate(aggregations)

Aggregate data from the tables in this set by performing some set of column operations on the groups and coalescing the results into a new Table <#agate.Table>.

aggregations must be a sequence of tuples, where each has two parts: a new_column_name and a Aggregation <#agate.Aggregation> instance.

The resulting table will have the keys from this TableSet (and any nested TableSets) set as its row_names. See Table.__init__() for more details.

bar_chart(label=0, value=1, path=None, width=None, height=None)

Render a lattice/grid of bar charts using leather.Lattice.

bins(*args, **kwargs)

Calls Table.bins() <#agate.Table.bins> on each table in the TableSet.

column_chart(label=0, value=1, path=None, width=None, height=None)

Render a lattice/grid of column charts using leather.Lattice.

compute(*args, **kwargs)

Calls Table.compute() <#agate.Table.compute> on each table in the TableSet.

count(value) -> integer -- return number of occurrences of value

denormalize(*args, **kwargs)

Calls Table.denormalize() <#agate.Table.denormalize> on each table in the TableSet.

dict()

Retrieve the contents of this sequence as an collections.OrderedDict.

distinct(*args, **kwargs)

Calls Table.distinct() <#agate.Table.distinct> on each table in the TableSet.

exclude(*args, **kwargs)

Calls Table.exclude() <#agate.Table.exclude> on each table in the TableSet.

find(*args, **kwargs)

Calls Table.find() <#agate.Table.find> on each table in the TableSet.

classmethod from_csv(dir_path, column_names=None, column_types=None, row_names=None, header=True, **kwargs)

Create a new TableSet from a directory of CSVs.

See Table.from_csv() <#agate.Table.from_csv> for additional details.

classmethod from_json(path, column_names=None, column_types=None, keys=None, **kwargs)

Create a new TableSet from a directory of JSON files or a single JSON object with key value (Table key and list of row objects) pairs for each Table <#agate.Table>.

See Table.from_json() <#agate.Table.from_json> for additional details.

get(key, default=None)

Equivalent to collections.OrderedDict.get().

group_by(*args, **kwargs)

Calls Table.group_by() <#agate.Table.group_by> on each table in the TableSet.

having(aggregations, test)

Create a new TableSet with only those tables that pass a test.

This works by applying a sequence of Aggregation <#agate.Aggregation> instances to each table. The resulting dictionary of properties is then passed to the test function.

This method does not modify the underlying tables in any way.

homogenize(*args, **kwargs)

Calls Table.homogenize() <#agate.Table.homogenize> on each table in the TableSet.

index(value[, start[, stop]]) -> integer -- return first index of value.

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

items()

Equivalent to collections.OrderedDict.items().

join(*args, **kwargs)

Calls Table.join() <#agate.Table.join> on each table in the TableSet.

keys()

Equivalent to collections.OrderedDict.keys().

limit(*args, **kwargs)

Calls Table.limit() <#agate.Table.limit> on each table in the TableSet.

line_chart(x=0, y=1, path=None, width=None, height=None)

Render a lattice/grid of line charts using leather.Lattice.

merge(groups=None, group_name=None, group_type=None)

Convert this TableSet into a single table. This is the inverse of Table.group_by() <#agate.Table.group_by>.

Any row_names set on the merged tables will be lost in this process.

normalize(*args, **kwargs)

Calls Table.normalize() <#agate.Table.normalize> on each table in the TableSet.

order_by(*args, **kwargs)

Calls Table.order_by() <#agate.Table.order_by> on each table in the TableSet.

pivot(*args, **kwargs)

Calls Table.pivot() <#agate.Table.pivot> on each table in the TableSet.

print_structure(max_rows=20, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)

Print the keys and row counts of each table in the tableset.

scatterplot(x=0, y=1, path=None, width=None, height=None)

Render a lattice/grid of scatterplots using leather.Lattice.

select(*args, **kwargs)

Calls Table.select() <#agate.Table.select> on each table in the TableSet.

to_csv(dir_path, **kwargs)

Write each table in this set to a separate CSV in a given directory.

See Table.to_csv() <#agate.Table.to_csv> for additional details.

to_json(path, nested=False, indent=None, **kwargs)

Write TableSet to either a set of JSON files for each table or a single nested JSON file.

See Table.to_json() <#agate.Table.to_json> for additional details.

values()

Equivalent to collections.OrderedDict.values().

where(*args, **kwargs)

Calls Table.where() <#agate.Table.where> on each table in the TableSet.

Parameters

keys()

Equivalent to collections.OrderedDict.keys().

values()

Equivalent to collections.OrderedDict.values().

items()

Equivalent to collections.OrderedDict.items().

get(key, default=None)

Equivalent to collections.OrderedDict.get().

dict()

Retrieve the contents of this sequence as an collections.OrderedDict.

Parameters

property index

This column's index.

property name

This column's name.

property data_type

This column's data type.

values()

Get the values in this column, as a tuple.

values_distinct()

Get the distinct values in this column, as a tuple.

values_without_nulls()

Get the values in this column with any null values removed.

values_sorted()

Get the values in this column sorted.

values_without_nulls_sorted()

Get the values in this column with any null values removed and sorted.

Parameters

null_values -- A sequence of values which should be cast to None when encountered by this data type.

test(d)

Test, for purposes of type inference, if a value could possibly be coerced to this data type.

This is really just a thin wrapper around DataType.cast().

cast(d)

Coerce a given string value into this column's data type.

csvify(d)

Format a given native value for CSV serialization.

jsonify(d)

Format a given native value for JSON serialization.

Parameters

cast_nulls -- If True, values in DEFAULT_NULL_VALUES will be converted to None. Disable to retain them as strings.

cast(d)

Cast a single value to unicode() (str() in Python 3).

Parameters

cast(d)

Cast a single value to a decimal.Decimal.

csvify(d)

Format a given native value for CSV serialization.

jsonify(d)

Format a given native value for JSON serialization.

Parameters

cast(d)

Cast a single value to bool.

jsonify(d)

Format a given native value for JSON serialization.

Parameters

cast(d)

Cast a single value to a datetime.date.

If both date_format and locale have been specified in the agate.Date instance, the cast() function is not thread-safe. :returns: datetime.date or None.

csvify(d)

Format a given native value for CSV serialization.

jsonify(d)

Format a given native value for JSON serialization.

Parameters

cast(d)

Cast a single value to a datetime.datetime.

If both date_format and locale have been specified in the agate.DateTime instance, the cast() function is not thread-safe. :returns: datetime.datetime or None.

csvify(d)

Format a given native value for CSV serialization.

jsonify(d)

Format a given native value for JSON serialization.

cast(d)

Cast a single value to datetime.timedelta.

1.

Boolean <#agate.Boolean>

2.

Number <#agate.Number>

3.

TimeDelta <#agate.TimeDelta>

4.

Date <#agate.Date>

5.

DateTime <#agate.DateTime>

6.

Text <#agate.Text>

Parameters

run(rows, column_names)

Apply type inference to the provided data and return an array of column types.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Parameters

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

1.

If no arguments are specified, then it will count the number of rows in the table.

2.

If only column_name is specified, then it will count the number of non-null values in that column.

3.

If both column_name and value are specified, then it will count occurrences of a specific value.

Parameters

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Parameters

column_name -- The name of the column to check.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of the column to be searched.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of the column to be searched.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Text <#agate.Text> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Parameters

column_name -- The name of the column to be searched.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

run(table)

Execute this aggregation on a given column and return the result.

Parameters

column_name -- The name of a column containing Number <#agate.Number> data.

get_aggregate_data_type(table)

Get the data type that should be used when using this aggregation with a TableSet <#agate.TableSet> to produce a new column.

Should raise UnsupportedAggregationError <#agate.UnsupportedAggregationError> if this column does not support aggregation into a TableSet <#agate.TableSet>. (For example, if it does not return a single value.)

validate(table)

Perform any checks necessary to verify this aggregation can run on the provided table without errors. This is called by Table.aggregate() <#agate.Table.aggregate> before run().

run(table)

Execute this aggregation on a given column and return the result.

Parameters

get_computed_data_type(table)

Returns an instantiated DataType <#agate.DataType> which will be appended to the table.

validate(table)

Perform any checks necessary to verify this computation can run on the provided table without errors. This is called by Table.compute() <#agate.Table.compute> before run().

run(table)

When invoked with a table, returns a sequence of new column values.

get_computed_data_type(table)

Returns an instantiated DataType <#agate.DataType> which will be appended to the table.

validate(table)

Perform any checks necessary to verify this computation can run on the provided table without errors. This is called by Table.compute() <#agate.Table.compute> before run().

run(table)

When invoked with a table, returns a sequence of new column values.

Parameters

get_computed_data_type(table)

Returns an instantiated DataType <#agate.DataType> which will be appended to the table.

run(table)

When invoked with a table, returns a sequence of new column values.

Parameters

get_computed_data_type(table)

Returns an instantiated DataType <#agate.DataType> which will be appended to the table.

validate(table)

Perform any checks necessary to verify this computation can run on the provided table without errors. This is called by Table.compute() <#agate.Table.compute> before run().

run(table)

Parameters

get_computed_data_type(table)

Returns an instantiated DataType <#agate.DataType> which will be appended to the table.

validate(table)

Perform any checks necessary to verify this computation can run on the provided table without errors. This is called by Table.compute() <#agate.Table.compute> before run().

run(table)

Parameters

column_name -- The name of a column containing the Number <#agate.Number> values.

validate(table)

Perform any checks necessary to verify this computation can run on the provided table without errors. This is called by Table.compute() <#agate.Table.compute> before run().

run(table)

Parameters

get_computed_data_type(table)

Returns an instantiated DataType <#agate.DataType> which will be appended to the table.

run(table)

Parameters

get_computed_data_type(table)

Returns an instantiated DataType <#agate.DataType> which will be appended to the table.

validate(table)

Perform any checks necessary to verify this computation can run on the provided table without errors. This is called by Table.compute() <#agate.Table.compute> before run().

run(table)

from agate import csv

property fieldnames

The names of the columns read from the schema.

locate(value)

Identify which quantile a given value is part of.

assertColumnNames(table, names)

Verify the column names in the given table match what is expected.

assertColumnTypes(table, types)

Verify the column types in the given table are of the expected types.

assertRows(table, rows)

Verify the row data in the given table match what is expected.

assertRowNames(table, names)

Verify the row names in the given table match what is expected.

Parameters

key -- The name of the configuration option.

Parameters

Parameters

hash -- A dictionary of option names and values.