Indexed vs. Table rows mismatch
Just doing what I'm told here by the exception :) 

``` python
  ...
  File "/home/tyler/repos/switchy/switchy/apps/measure/metrics.py", line 164, in append_row
    self._store.append('data', self._df, dropna=False)
  File "/usr/lib/python2.7/site-packages/pandas/io/pytables.py", line 912, in append
    **kwargs)
  File "/usr/lib/python2.7/site-packages/pandas/io/pytables.py", line 1268, in _write_to_group
    s.write(obj=value, append=append, complib=complib, **kwargs)
  File "/usr/lib/python2.7/site-packages/pandas/io/pytables.py", line 3805, in write
    self.write_data(chunksize, dropna=dropna)
  File "/usr/lib/python2.7/site-packages/pandas/io/pytables.py", line 3880, in write_data
    values=[v[start_i:end_i] for v in bvalues])
  File "/usr/lib/python2.7/site-packages/pandas/io/pytables.py", line 3926, in write_data_chunk
    raise TypeError("tables cannot write this data -> %s" % detail)
TypeError: tables cannot write this data -> internal error: the number of indexed rows (4096)
 and rows in the table (2048) is not equal; please report this to the authors.
```

What I'm doing...
I create a data frame and a store inside an instance:

``` python
class DataStore(object):                                               
    """Wraps a `pd.DataFrame` which buffers recent data in memory and  
    offloads excess to disk using the HDF5 format.                     
    """                                                                
    def __init__(self, data=None, columns=None, size=2**9,             
                 hdf_path=None, metrics_func=lambda df: df):           

        self._df = pd.DataFrame(                                       
            data=data,                                                 
            columns=columns,                                           
            index=range(size) if data is None else None,               
            dtype=np.float64,                                          
        )                                                              
        self._len = len(self._df)                                      
        # current row insertion-index                                  
        self._ri = 0 if data is None else len(self._df) - 1            
        self._store = pd.HDFStore(                                     
            hdf_path or tempfile.mktemp() + '_switchy_metrics.h5'      
        )                                                              
        self._store.open('a')                                          
        self._mfunc = metrics_func                                     
```

An event loop writes rows to this instance using the following method:

``` python
 def append_row(self, row=None):                                            
    '''Insert :var:`row` into the internal data frame at the current index 
    and increment. Return a bool indicating whether the current entry has  
    caused a flush to disk.            
    '''                                                                    
    flush = False                                                          
    i = self.findex   # just the row index modulo len(self.df)                                                       
    if self._ri > self._len - 1 and i == 0:                                
        # offload frame to disk                                            
        self._store.append('data', self._df, dropna=False)                 
        flush = True                                                       
    self._df.values[i, :] = row                                            
    self._ri += 1                                                          
    return flush                                                           
```

So, in english, every time the in mem data frame fills up (i.e. after 512 rows insertions), write the `self._df` frame to disk by appending to the HDF table.

I'm assuming this is a PyTables issue. If there's something wrong with my usage I'd be glad to know. Also note this error only shows up a fraction of the times `self._store.append('data', self._df, dropna=False)` is actually called. The event loop rate is ~ 30 insertions / second but the target is to get it much higher.

Version info:

``` python
In [2]: show_versions()

INSTALLED VERSIONS
------------------
commit: None
python: 2.7.10.final.0
python-bits: 64
OS: Linux
OS-release: 4.0.7-2-ARCH
machine: x86_64
processor: 
byteorder: little
LC_ALL: None
LANG: en_US.UTF-8

pandas: 0.16.2
nose: 1.3.7
Cython: None
numpy: 1.9.2
scipy: 0.16.0
statsmodels: None
IPython: 4.0.0
sphinx: 1.3.1
patsy: None
dateutil: 2.4.2
pytz: 2015.4
bottleneck: None
tables: 3.2.1
numexpr: 2.4.3
matplotlib: 1.4.3
openpyxl: None
xlrd: None
xlwt: None
xlsxwriter: None
lxml: None
bs4: None
html5lib: None
httplib2: None
apiclient: None
sqlalchemy: 0.6.9
pymysql: None
psycopg2: 2.6.1 (dt dec pq3 ext lo64)
```
