visidata 2.11.1__py3-none-any.whl → 3.0__py3-none-any.whl

visidata/keys.py

@@ -8,6 +8,8 @@ visidata.vd.prettykeys_trdict = {
         '^J': 'Enter',
         '^M': 'Enter',
         '^I': 'Tab',
+        'KEY_BTAB': 'Shift+Tab',
+        '^@': 'Ctrl+Space',
         'KEY_UP':    'Up',
         'KEY_DOWN':  'Down',
         'KEY_LEFT':  'Left',
@@ -30,6 +32,8 @@ visidata.vd.prettykeys_trdict = {
         'kNXT5':     'Ctrl+PgDn',
         'KEY_IC5':   'Ctrl+Ins',
         'KEY_DC5':   'Ctrl+Del',
+        'kDC5':      'Ctrl+Del',
+        'KEY_SDC':   'Shift+Del',
 
         'KEY_IC':    'Ins',
         'KEY_DC':    'Del',
@@ -47,24 +51,21 @@ visidata.vd.prettykeys_trdict = {
         'BUTTON1_PRESSED': 'LeftClick',
         'BUTTON2_PRESSED': 'MiddleClick',
         'BUTTON3_PRESSED': 'RightClick',
-        'BUTTON4_PRESSED': 'ScrollwheelUp',
-        'BUTTON5_PRESSED': 'ScrollwheelDown',
-        'REPORT_MOUSE_POSITION': 'ScrollwheelDown',
-        '2097152': 'ScrollwheelDown',
-        'KEY_F(1)': 'F1',
-        'KEY_F(2)': 'F2',
-        'KEY_F(3)': 'F3',
-        'KEY_F(4)': 'F4',
-        'KEY_F(5)': 'F5',
-        'KEY_F(6)': 'F6',
-        'KEY_F(7)': 'F7',
-        'KEY_F(8)': 'F8',
-        'KEY_F(9)': 'F9',
-        'KEY_F(10)': 'F10',
-        'KEY_F(11)': 'F11',
-        'KEY_F(12)': 'F12',
+        'BUTTON4_PRESSED': 'ScrollUp',
+        'BUTTON5_PRESSED': 'ScrollDown',
+        'REPORT_MOUSE_POSITION': 'ScrollDown',
+        '2097152': 'ScrollDown',
     }
 
+for i in range(1, 13):
+    d = visidata.vd.prettykeys_trdict
+    d[f'KEY_F({i})'] = f'F{i}'
+    d[f'KEY_F({i+12})'] = f'Shift+F{i}'
+    d[f'KEY_F({i+24})'] = f'Ctrl+F{i}'
+    d[f'KEY_F({i+36})'] = f'Ctrl+Shift+F{i}'
+    d[f'KEY_F({i+48})'] = f'Alt+F{i}'
+    d[f'KEY_F({i+60})'] = f'Alt+Shift+F{i}'
+
 
 @visidata.VisiData.api
 def prettykeys(vd, key):

visidata/loaders/__init__.py

@@ -0,0 +1,9 @@
+from visidata import vd, IndexSheet
+
+
+vd.option('load_lazy', False, 'load subsheets always (False) or lazily (True)')
+vd.option('skip', 0, 'skip N rows before header', replay=True)
+vd.option('header', 1, 'parse first N rows as column names', replay=True)
+
+IndexSheet.options.header = 0
+IndexSheet.options.skip = 0

visidata/loaders/_pandas.py

@@ -4,23 +4,57 @@ from visidata import VisiData, vd, Sheet, date, anytype, Path, options, Column,
 
 @VisiData.api
 def open_pandas(vd, p):
-    return PandasSheet(p.name, source=p)
+    return PandasSheet(p.base_stem, source=p)
 
 @VisiData.api
 def open_dta(vd, p):
-    return PandasSheet(p.name, source=p, filetype='stata')
+    return PandasSheet(p.base_stem, source=p, filetype='stata')
 
 VisiData.open_stata = VisiData.open_pandas
 
 for ft in 'feather gbq orc pickle sas stata'.split():
     funcname ='open_'+ft
     if not getattr(VisiData, funcname, None):
-        setattr(VisiData, funcname, lambda vd,p,ft=ft: PandasSheet(p.name, source=p, filetype=ft))
+        setattr(VisiData, funcname, lambda vd,p,ft=ft: PandasSheet(p.base_stem, source=p, filetype=ft))
 
+@VisiData.api
+@asyncthread
+def save_dta(vd, p, *sheets):
+    import pandas as pd
+    import numpy as np
+
+    # STATA is a one-sheet software
+    # Save only the first sheet
+    vs = sheets[0]
+
+    columns = [col.name for col in vs.visibleCols]
+    
+    # Get data types
+    types = list()
+    dispvals = next(vs.iterdispvals(format=True))
+    for col,_ in dispvals.items():
+        if col.type in [bool, int, float]:
+            types.append(col.type)
+        elif vd.isNumeric(col):
+            types.append(float)
+        else:
+            types.append(str)
+
+    # Populate numpy array
+    data = np.empty((vs.nRows, len(columns)), dtype=object)
+    for r_i, dispvals in enumerate(vs.iterdispvals(format=True)):
+        for c_i, v in enumerate(dispvals.values()):
+            data[r_i, c_i] = v
+
+    # Convert to pandas DataFrame and save
+    dtype = {col:t for col,t in zip(columns, types)}
+    df = pd.DataFrame(data, columns=columns)
+    df = df.astype(dtype)
+    df.to_stata(p, version=118, write_index=False)
 
 class DataFrameAdapter:
     def __init__(self, df):
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         if not isinstance(df, pd.DataFrame):
             vd.fail('%s is not a dataframe' % type(df).__name__)
 
@@ -57,7 +91,7 @@ class PandasSheet(Sheet):
     '''
 
     def dtype_to_type(self, dtype):
-        import numpy as np
+        np = vd.importExternal('numpy')
         # Find the underlying numpy dtype for any pandas extension dtypes
         dtype = getattr(dtype, 'numpy_dtype', dtype)
         try:
@@ -74,7 +108,7 @@ class PandasSheet(Sheet):
 
     def read_tsv(self, path, **kwargs):
         'Partial function for reading TSV files using pd.read_csv'
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         return pd.read_csv(path, sep='\t', **kwargs)
 
     @property
@@ -111,7 +145,7 @@ class PandasSheet(Sheet):
 
     @asyncthread
     def reload(self):
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         if isinstance(self.source, pd.DataFrame):
             df = self.source
         elif isinstance(self.source, Path):
@@ -124,6 +158,12 @@ class PandasSheet(Sheet):
                 readfunc = getattr(pd, 'read_'+filetype) or vd.error('no pandas.read_'+filetype)
             # readfunc() handles binary and text open()
             df = readfunc(self.source, **options.getall('pandas_'+filetype+'_'))
+            # some read methods (html, for example) return a list of dataframes
+            if isinstance(df, list):
+                for idx, inner_df in enumerate(df[1:], start=1):
+                    vd.push(PandasSheet(f'{self.name}[{idx}]', source=inner_df))
+                df = df[0]
+                self.name += '[0]'
             if (filetype == 'pickle') and not isinstance(df, pd.DataFrame):
                 vd.fail('pandas loader can only unpickle dataframes')
         else:
@@ -169,7 +209,7 @@ class PandasSheet(Sheet):
         self.rows.sort_values(by=by_cols, ascending=ascending, inplace=True)
 
     def _checkSelectedIndex(self):
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         if self._selectedMask.index is not self.df.index:
             # DataFrame was modified inplace, so the selection is no longer valid
             vd.status('pd.DataFrame.index updated, clearing {} selected rows'
@@ -224,7 +264,7 @@ class PandasSheet(Sheet):
             self.unselectRow(row)
 
     def clearSelected(self):
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         self._selectedMask = pd.Series(False, index=self.df.index)
 
     def selectByIndex(self, start=None, end=None):
@@ -251,7 +291,7 @@ class PandasSheet(Sheet):
         matching rows to the selection. If unselect is True, remove from the
         active selection instead.
         '''
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         case_sensitive = 'I' not in vd.options.regex_flags
         masks = pd.DataFrame([
             self.df[col.expr].astype(str).str.contains(pat=regex, case=case_sensitive, regex=True)
@@ -278,13 +318,13 @@ class PandasSheet(Sheet):
         DataFrame's dtypes.
         '''
 
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         return pd.DataFrame({
             col: [None] * n for col in self.df.columns
         }).astype(self.df.dtypes.to_dict(), errors='ignore')
 
     def addRows(self, rows, index=None, undo=True):
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         if index is None:
             self.df = self.df.append(pd.DataFrame(rows))
         else:
@@ -296,7 +336,7 @@ class PandasSheet(Sheet):
             vd.addUndo(self._deleteRows, range(index, index + len(rows)))
 
     def _deleteRows(self, which):
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         self.df.drop(which, inplace=True)
         self.df.index = pd.RangeIndex(self.nRows)
         self._checkSelectedIndex()
@@ -306,7 +346,7 @@ class PandasSheet(Sheet):
         vd.addUndo(self._deleteRows, index or self.nRows - 1)
 
     def delete_row(self, rowidx):
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         oldrow = self.df.iloc[rowidx:rowidx+1]
 
         # Use to_dict() here to work around an edge case when applying undos.
@@ -321,7 +361,7 @@ class PandasSheet(Sheet):
 
     def deleteBy(self, by):
         '''Delete rows for which func(row) is true.  Returns number of deleted rows.'''
-        import pandas as pd
+        pd = vd.importExternal('pandas')
         nRows = self.nRows
         vd.addUndo(setattr, self, 'df', self.df.copy())
         self.df = self.df[~by]
@@ -353,17 +393,17 @@ PandasSheet.addCommand(None, 'unselect-before', 'unselectByIndex(end=cursorRowIn
 PandasSheet.addCommand(None, 'stoggle-after', 'toggleByIndex(start=cursorRowIndex)', 'toggle selection of rows from cursor to bottom')
 PandasSheet.addCommand(None, 'select-after', 'selectByIndex(start=cursorRowIndex)', 'select all rows from cursor to bottom')
 PandasSheet.addCommand(None, 'unselect-after', 'unselectByIndex(start=cursorRowIndex)', 'unselect all rows from cursor to bottom')
-PandasSheet.addCommand(None, 'random-rows', 'nrows=int(input("random number to select: ", value=nRows)); vs=copy(sheet); vs.name=name+"_sample"; vs.rows=DataFrameAdapter(sheet.df.sample(nrows or nRows)); vd.push(vs)', 'open duplicate sheet with a random population subset of N rows'),
+PandasSheet.addCommand(None, 'random-rows', 'nrows=int(input("random number to select: ", value=nRows)); vs=copy(sheet); vs.name=name+"_sample"; vs.rows=DataFrameAdapter(sheet.df.sample(nrows or nRows)); vd.push(vs)', 'open duplicate sheet with a random population subset of N rows')
 
 # Handle the regex selection family of commands through a single method,
 # since the core logic is shared
-PandasSheet.addCommand('|', 'select-col-regex', 'selectByRegex(regex=input("select regex: ", type="regex", defaultLast=True), columns=[cursorCol])', 'select rows matching regex in current column')
-PandasSheet.addCommand('\\', 'unselect-col-regex', 'selectByRegex(regex=input("select regex: ", type="regex", defaultLast=True), columns=[cursorCol], unselect=True)', 'unselect rows matching regex in current column')
-PandasSheet.addCommand('g|', 'select-cols-regex', 'selectByRegex(regex=input("select regex: ", type="regex", defaultLast=True), columns=visibleCols)', 'select rows matching regex in any visible column')
-PandasSheet.addCommand('g\\', 'unselect-cols-regex', 'selectByRegex(regex=input("select regex: ", type="regex", defaultLast=True), columns=visibleCols, unselect=True)', 'unselect rows matching regex in any visible column')
+PandasSheet.addCommand('|', 'select-col-regex', 'selectByRegex(regex=inputRegex("select regex: ", defaultLast=True), columns=[cursorCol])', 'select rows matching regex in current column')
+PandasSheet.addCommand('\\', 'unselect-col-regex', 'selectByRegex(regex=inputRegex("select regex: ", defaultLast=True), columns=[cursorCol], unselect=True)', 'unselect rows matching regex in current column')
+PandasSheet.addCommand('g|', 'select-cols-regex', 'selectByRegex(regex=inputRegex("select regex: ", defaultLast=True), columns=visibleCols)', 'select rows matching regex in any visible column')
+PandasSheet.addCommand('g\\', 'unselect-cols-regex', 'selectByRegex(regex=inputRegex("select regex: ", defaultLast=True), columns=visibleCols, unselect=True)', 'unselect rows matching regex in any visible column')
 
 # Override with a pandas/dataframe-aware implementation
-PandasSheet.addCommand('"', 'dup-selected', 'vs=PandasSheet(sheet.name, "selectedref", source=selectedRows.df); vd.push(vs)', 'open duplicate sheet with only selected rows'),
+PandasSheet.addCommand('"', 'dup-selected', 'vs=PandasSheet(sheet.name, "selectedref", source=selectedRows.df); vd.push(vs)', 'open duplicate sheet with only selected rows')
 
 vd.addGlobals({
     'PandasSheet': PandasSheet,

visidata/loaders/api_airtable.py

@@ -0,0 +1,70 @@
+import re
+import os
+
+from visidata import vd, date, asyncthread, VisiData, Progress, Sheet, Column, ItemColumn, deduceType, TypedWrapper, setitem
+
+
+vd.option('airtable_auth_token', '', 'Airtable API key from https://airtable.com/account')
+
+airtable_regex = r'^https://airtable.com/(app[A-Za-z0-9]+)/(tbl[A-Za-z0-9]+)/?(viw[A-z0-9]+)?'
+
+@VisiData.api
+def guessurl_airtable(vd, p, response):
+    m = re.search(airtable_regex, p.given)
+    if m:
+        return dict(filetype='airtable', _likelihood=10)
+
+
+@VisiData.api
+def open_airtable(vd, p):
+    pyairtable = vd.importExternal('pyairtable')
+
+    token = os.environ.get('AIRTABLE_AUTH_TOKEN') or vd.options.airtable_auth_token
+    if not token:
+        vd.requireOptions('airtable_auth_token', help='https://support.airtable.com/docs/creating-and-using-api-keys-and-access-tokens')
+
+    m = re.search(airtable_regex, p.given)
+    if not m:
+        vd.fail('invalid airtable url')
+
+    app, tbl, viw = m.groups()
+    return AirtableSheet('airtable', source=p,
+                         airtable_auth_token=token,
+                         airtable_base=app,
+                         airtable_table=tbl,
+                         airtable_view=viw)
+
+
+class AirtableSheet(Sheet):
+    guide = '''
+        # Airtable
+        This sheet is a read-only download of all records in a table at _airtable.com_.
+    '''
+    rowtype = 'records'  # rowdef: dict
+
+    columns = [
+        ItemColumn('id', 'id', type=str, width=0),
+        ItemColumn('createdTime', 'createdTime', type=date, width=0)
+    ]
+
+    def iterload(self):
+        self.fields = set()
+
+        for page in self.api.iterate(self.airtable_base, self.airtable_table, view=self.airtable_view):
+            for row in page:
+                yield row
+
+                for field, value in row['fields'].items():
+                    if field not in self.fields:
+                        col = ItemColumn('fields.'+field, type=deduceType(value))
+                        self.addColumn(col)
+                        self.fields.add(field)
+
+    def newRow(self):
+        return AttrDict(fields=AttrDict())
+
+
+@AirtableSheet.lazy_property
+def api(self):
+    import pyairtable
+    return pyairtable.Api(self.airtable_auth_token)

visidata/loaders/api_bitio.py

@@ -0,0 +1,102 @@
+
+from visidata import *
+
+vd.option('bitio_api_key', '', 'API key')
+
+@VisiData.api
+def new_bitio(vd, p):
+    vd.importExternal('bitdotio')
+    vd.requireOptions('bitio_api_key', help='https://docs.bit.io/docs/connecting-via-the-api')
+    return BitioReposSheet(p.name, source=p)
+
+vd.openhttp_bitio = vd.new_bitio
+
+@VisiData.lazy_property
+def bitio_client(vd):
+    import bitdotio
+    return bitdotio.bitdotio(vd.options.bitio_api_key)
+
+@VisiData.api
+def bitio_api(vd, path, method, **kwargs):
+    t = vd.bitio_client.api_client.call_api(path, method,
+            header_params={'Accept': 'application/json',
+                           'Authorization': 'Bearer '+vd.bitio_client.access_token,
+                           'Content-Type': 'application/json'}, async_req=True, body=kwargs)
+    if not t.successful():
+        vd.warning(resp['Reason'])
+    return t.get()
+
+
+class BitioReposSheet(Sheet):
+    rowtype = 'repos'
+    columns = [
+        AttrColumn('name'),
+        AttrColumn('creator'),
+        AttrColumn('owner'),
+        AttrColumn('bytes', type=int, width=0),
+        AttrColumn('collaborators'),
+        AttrColumn('description'),
+        AttrColumn('documentation'),
+        AttrColumn('endpoints'),
+        AttrColumn('is_private'),
+        AttrColumn('license'),
+        AttrColumn('query_count'),
+        AttrColumn('stars'),
+        AttrColumn('tables'),
+        AttrColumn('url'),
+        AttrColumn('watchers'),
+    ]
+    defer = True
+    def iterload(self):
+        yield from vd.bitio_client.list_repos(self.source.name)
+
+
+    @asyncthread
+    def putChanges(self):
+        adds, mods, dels = self.getDeferredChanges()
+        for row in dels.values():
+            vd.bitio_api(f'/users/{self.source.name}/repos/{row.name}/', 'DELETE')
+
+        for row, rowmods in Progress(list(mods.values()), gerund="updating"):
+            kwargs = {col.name: val for col, val in rowmods.items()}
+            vd.bitio_api(f'/users/{self.source.name}/repos/{row.name}/', 'PATCH', **kwargs)
+
+    def openRow(self, row):
+        return BitioRepoSheet(self.source.name, row.name, source=row)
+
+
+class BitioRepoSheet(Sheet):
+    rowtype = 'tables'
+    columns = [
+        AttrColumn('url'),
+        AttrColumn('current_name'),
+        AttrColumn('description'),
+        AttrColumn('columns'),
+        AttrColumn('num_records', type=int),
+        AttrColumn('bytes', type=int),
+        AttrColumn('repo'),
+        AttrColumn('documentation'),
+    ]
+    def iterload(self):
+        yield from vd.bitio_client.list_tables(self.source.owner.split('/')[-2], self.source.name)
+
+    def openRow(self, row):
+        username = row.repo.split('/')[-4]
+        repo = row.repo.split('/')[-2]
+        return BitioTable(username, repo, source=row)
+
+
+class BitioTable(Sheet):
+    def iterload(self):
+        username = self.source.repo.split('/')[-4]
+        repo = self.source.repo.split('/')[-2]
+        conn = vd.bitio_client.get_connection()
+        with conn.cursor() as cur:
+            cur.execute(f'SELECT * FROM "{username}/{repo}"."{self.source.current_name}"')
+            r = cur.fetchone()
+            if r:
+                yield r
+            self.columns = []
+            for c in vd.postgresGetColumns(cur):
+                self.addColumn(c)
+            yield from cur

visidata/loaders/api_matrix.py

@@ -0,0 +1,148 @@
+'''
+# Matrix Chat Sheet
+A list of messages from [:underline]{sheet.sourcename}[/].
+
+- `Enter` to push a sheet with all the messages from [:underline]{sheet.cursorRow.room.display_name}[/].
+- `a` to send a message to [:underline]{sheet.cursorRow.room.display_name}[/].
+'''
+
+from visidata import vd, VisiData, Sheet, Column, ItemColumn, date, asyncthread, AttrDict, vlen, Path
+
+
+vd.option('matrix_token', '', 'matrix API token')
+vd.option('matrix_user_id', '', 'matrix user ID associated with token')
+vd.option('matrix_device_id', 'VisiData', 'device ID associated with matrix login')
+
+vd.matrix_client = None
+
+
+@VisiData.api
+def openhttp_matrix(vd, p):
+    vd.importExternal('matrix_client')
+
+    if not vd.options.matrix_token:
+        from matrix_client.client import MatrixClient
+
+        username = vd.input(f'{p.given} username: ', record=False)
+        password = vd.input('password: ', record=False, display=False)
+
+        vd.matrix_client = MatrixClient(p.given)
+        matrix_token = vd.matrix_client.login(username, password, device_id=vd.options.matrix_device_id)
+
+        vd.setPersistentOptions(matrix_user_id=username, matrix_token=matrix_token)
+
+    vd.timeouts_before_idle = -1
+    return MatrixSheet(p.base_stem, source=p)
+
+vd.open_matrix = vd.openhttp_matrix
+
+
+class MatrixRoomsSheet(Sheet):
+    def iterload(self):
+        yield from vd.matrix_client.get_rooms().values()
+
+
+class MatrixSheet(Sheet):
+    help = __doc__
+    columns = [
+        Column('room', width=12, getter=lambda c,r: r.room and r.room.display_name),
+        ItemColumn('sender', width=0),
+        Column('sender', width=10, getter=lambda c,r: r.sender.split(':')[0][1:]),
+        Column('timestamp', width=16, type=date, getter=lambda c,r: r and r.origin_server_ts/1000, fmtstr='%Y-%m-%d %H:%m'),
+        ItemColumn('type', width=15),
+        ItemColumn('content', width=0),
+        ItemColumn('content.body', width=50),
+        ItemColumn('received', type=vlen, width=0),
+        ItemColumn('content.msgtype'),
+    ]
+
+    @property
+    def sourcename(self):
+        from matrix_client.room import Room
+        if isinstance(self.source, Room):
+            return self.source.display_name or self.source.room_id
+        else:
+            return str(self.source)
+
+    @asyncthread
+    def reload(self):
+        from matrix_client.client import MatrixClient
+        from matrix_client.room import Room
+        if not vd.matrix_client:
+            vd.matrix_client = MatrixClient(self.source.given,
+                                        token=self.options.matrix_token,
+                                        user_id=self.options.matrix_user_id)
+
+        if isinstance(self.source, Room):
+            self.add_room(self.source)
+            self.get_room_messages(self.source)
+            return
+
+        for room in vd.matrix_client.get_rooms().values():
+            self.add_room(room)
+            room.backfill_previous_messages(limit=1)
+
+        vd.matrix_client.add_listener(self.global_event)
+        vd.matrix_client.add_ephemeral_listener(self.global_event)
+
+        vd.matrix_client.start_listener_thread(exception_handler=vd.exceptionCaught)
+
+        vd.matrix_client._sync()
+
+        vd.matrix_client.listen_for_events() # vd.matrix_client.sync(full_state=True)
+
+    def add_room(self, room):
+        room.add_listener(self.room_event)
+        room.add_ephemeral_listener(self.room_event)
+        room.add_state_listener(self.global_event)
+
+    @asyncthread
+    def get_room_messages(self, room):
+            while room.prev_batch:
+                ret = vd.matrix_client.api.get_room_messages(room.room_id, room.prev_batch, direction='b', limit=100)
+                for r in ret['chunk']:
+                    r['room'] = room
+                    self.addRow(r)
+
+                if 'end' not in ret or ret['end'] == room.prev_batch:
+                    break
+                room.prev_batch = ret['end']
+
+    def addRow(self, r, **kwargs):
+        r = AttrDict(r)
+        if r.event_id not in self.event_index:
+            super().addRow(r, **kwargs)
+            self.event_index[r.event_id] = r
+
+    def global_event(self, chunk):
+        self.addRow(chunk)
+
+    def room_event(self, room, chunk):
+        ev = AttrDict(chunk)
+        t = chunk['type']
+        if t == 'm.receipt':
+            for msgid, content in chunk['content'].items():
+                msg = self.event_index.setdefault(msgid, {})
+                if 'received' not in msg:
+                    msg['received'] = {}
+
+                for t, c in content.items():
+                    assert t == 'm.read'
+                    for userid, v in c.items():
+                        msg['received'][(t, userid)] = v['ts']/1000
+            return
+
+        chunk['room'] = room
+        self.addRow(chunk)
+
+    def add_message(self, text):
+        vd.matrix_client.send_text(text)
+
+    def openRow(self, row):
+        return MatrixSheet(row.room.display_name, source=row.room, last_id=row.event_id)
+
+
+MatrixSheet.init('event_index', dict)
+
+MatrixSheet.addCommand('a', 'add-row', 'cursorRow.room.send_text(input(cursorRow.room.display_name+"> "))', 'send chat message to current room')
+vd.addMenuItems('Row > Add > send matrix message > add-msg')