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

visidata/loaders/api_reddit.py

@@ -0,0 +1,306 @@
+'''# RedditSheet
+
+- [:keys]Ctrl+O[/] to open a browser tab to [:code]{sheet.cursorRow.display_name_prefixed}[/]
+- [:keys]g Ctrl+O[/] to open browser windows for {sheet.nSelectedRows} selected subreddits
+
+- [:keys]Enter[/] to open sheet with top ~1000 submissions for [:code]{sheet.cursorRow.display_name_prefixed}[/]
+- [:keys]g Enter[/] to open sheet with top ~1000 submissions for {sheet.nSelectedRows} selected subreddits
+
+- [:keys]ga[/] to append more subreddits matching input by name or description
+'''
+
+import visidata
+from visidata import vd, VisiData, Sheet, AttrColumn, asyncthread, ENTER, anytype, date
+
+
+vd.option('reddit_client_id', '', 'client_id for reddit api')
+vd.option('reddit_client_secret', '', 'client_secret for reddit api')
+vd.option('reddit_user_agent', visidata.__version__, 'user_agent for reddit api')
+
+
+@VisiData.api
+def open_reddit(vd, p):
+    vd.importExternal('praw')
+    vd.enable_requests_cache()
+
+    if not vd.options.reddit_client_id:
+        return RedditGuide('reddit_guide')
+
+    if p.given.startswith('r/') or p.given.startswith('/r/'):
+        return SubredditSheet(p.base_stem, source=p.base_stem.split('+'), search=(p.given[0]=='/'))
+
+    if p.given.startswith('u/') or p.given.startswith('/u/'):
+        return RedditorsSheet(p.base_stem, source=p.base_stem.split('+'), search=(p.given[0]=='/'))
+
+    return SubredditSheet(p.base_stem, source=p)
+
+vd.new_reddit = vd.open_reddit
+
+@VisiData.cached_property
+def reddit(vd):
+    import praw
+    return praw.Reddit(check_for_updates=False, **vd.options.getall('reddit_'))
+
+
+subreddit_hidden_attrs='''
+name #accounts_active accounts_active_is_fuzzed advertiser_category
+all_original_content allow_chat_post_creation allow_discovery
+allow_galleries allow_images allow_polls allow_predictions
+allow_predictions_tournament allow_videogifs allow_videos
+banner_background_color banner_background_image banner_img banner_size
+can_assign_link_flair can_assign_user_flair collapse_deleted_comments
+comment_score_hide_mins community_icon community_reviewed @created
+@created_utc description_html disable_contributor_requests
+display_name display_name_prefixed emoji emojis_custom_size
+emojis_enabled filters free_form_reports fullname has_menu_widget
+header_img header_size header_title hide_ads icon_img icon_size
+is_chat_post_feature_enabled is_crosspostable_subreddit
+is_enrolled_in_new_modmail key_color lang link_flair_enabled
+link_flair_position mobile_banner_image mod notification_level
+original_content_tag_enabled over18 prediction_leaderboard_entry_type
+primary_color public_description public_description_html public_traffic
+quaran quarantine restrict_commenting restrict_posting show_media
+show_media_preview spoilers_enabled submission_type submit_link_label
+submit_text submit_text_html submit_text_label suggested_comment_sort
+user_can_flair_in_sr user_flair_background_color user_flair_css_class
+user_flair_enabled_in_sr user_flair_position user_flair_richtext
+user_flair_template_id user_flair_text user_flair_text_color
+user_flair_type user_has_favorited user_is_banned user_is_contributor
+user_is_moderator user_is_muted user_is_subscriber user_sr_flair_enabled
+user_sr_theme_enabled #videostream_links_count whitelist_status widgets
+wiki wiki_enabled wls
+'''
+
+post_hidden_attrs='''
+all_awardings allow_live_comments @approved_at_utc approved_by archived
+author_flair_background_color author_flair_css_class author_flair_richtext
+author_flair_template_id author_flair_text author_flair_text_color
+author_flair_type author_fullname author_patreon_flair author_premium
+awarders @banned_at_utc banned_by can_gild can_mod_post category clicked
+comment_limit comment_sort content_categories contest_mode @created_utc
+discussion_type distinguished domain edited flair fullname gilded
+gildings hidden hide_score is_crosspostable is_meta is_original_content
+is_reddit_media_domain is_robot_indexable is_self is_video likes
+link_flair_background_color link_flair_css_class link_flair_richtext
+link_flair_text link_flair_text_color link_flair_type locked media
+media_embed media_only mod mod_note mod_reason_by mod_reason_title
+mod_reports name no_follow num_crossposts num_duplicates num_reports
+over_18 parent_whitelist_status permalink pinned pwls quarantine
+removal_reason removed_by removed_by_category report_reasons saved
+score secure_media secure_media_embed selftext_html send_replies
+shortlink spoiler stickied subreddit_id subreddit_name_prefixed
+subreddit_subscribers subreddit_type suggested_sort thumbnail
+thumbnail_height thumbnail_width top_awarded_type total_awards_received
+treatment_tags upvote_ratio user_reports #view_count visited
+whitelist_status wls
+'''
+
+comment_hidden_attrs='''
+all_awardings @approved_at_utc approved_by archived associated_award
+author_flair_background_color author_flair_css_class author_flair_richtext
+author_flair_template_id author_flair_text author_flair_text_color
+author_flair_type author_fullname author_patreon_flair author_premium
+awarders @banned_at_utc banned_by body_html can_gild can_mod_post
+collapsed collapsed_because_crowd_control collapsed_reason comment_type
+controversiality @created_utc distinguished fullname gilded gildings
+is_root is_submitter likes link_id locked mod mod_note mod_reason_by
+mod_reason_title mod_reports name no_follow num_reports parent_id
+permalink removal_reason report_reasons saved #score #score_hidden
+send_replies stickied submission subreddit_id subreddit_name_prefixed
+subreddit_type top_awarded_type total_awards_received treatment_tags
+user_reports
+'''
+
+redditor_hidden_attrs='''
+#awardee_karma #awarder_karma @created @created_utc
+fullname has_subscribed has_verified_email hide_from_robots icon_img id
+is_employee is_friend is_gold is_mod pref_show_snoovatar
+snoovatar_img snoovatar_size stream #total_karma verified
+subreddit.banner_img subreddit.name subreddit.over_18 subreddit.public_description #subreddit.subscribers subreddit.title
+'''
+
+def hiddenCols(hidden_attrs):
+    coltypes = { t.icon:t.typetype for t in vd.typemap.values() if not t.icon.isalpha() }
+    for attr in hidden_attrs.split():
+        coltype = anytype
+        if attr[0] in coltypes:
+            coltype = coltypes.get(attr[0])
+            attr = attr[1:]
+        yield AttrColumn(attr, type=coltype, width=0)
+
+
+class SubredditSheet(Sheet):
+    guide = __doc__
+    # source is a text list of subreddits
+    rowtype = 'subreddits'  # rowdef: praw.Subreddit
+    nKeys=1
+    search=False
+    columns = [
+        AttrColumn('display_name_prefixed', width=15),
+        AttrColumn('active_user_count', type=int),
+        AttrColumn('subscribers', type=int),
+        AttrColumn('subreddit_type'),
+        AttrColumn('title'),
+        AttrColumn('description', width=50),
+        AttrColumn('url', width=10),
+    ] + list(hiddenCols(subreddit_hidden_attrs))
+
+    def iterload(self):
+        for name in self.source:
+            name = name.strip()
+            if self.search:
+                yield from vd.reddit.subreddits.search(name)
+            else:
+                try:
+                    r = vd.reddit.subreddit(name)
+                    r.display_name_prefixed
+                    yield r
+                except Exception as e:
+                    vd.exceptionCaught(e)
+
+    def openRow(self, row):
+        return RedditSubmissions(row.display_name_prefixed, source=row)
+
+    def openRows(self, rows):
+        comboname = '+'.join(row.display_name for row in rows)
+        return RedditSubmissions(comboname, source=vd.reddit.subreddit(comboname))
+
+
+class RedditorsSheet(Sheet):
+    # source is a text list of usernames
+    rowtype = 'redditors'  # rowdef: praw.Subreddit
+    nKeys=1
+    columns = [
+        AttrColumn('name', width=15),
+        AttrColumn('comment_karma', type=int),
+        AttrColumn('link_karma', type=int),
+        AttrColumn('comments'),
+        AttrColumn('submissions'),
+    ] + list(hiddenCols(redditor_hidden_attrs))
+
+    def iterload(self):
+        for name in self.source:
+            if self.search:
+                yield from vd.reddit.redditors.popular(name)
+            else:
+                yield vd.reddit.redditor(name)
+
+    def openRow(self, row):
+        return RedditSubmissions(row.fullname, source=row.submissions)
+
+    def openRows(self, rows):
+        comboname = '+'.join(row.name for row in rows)
+        return RedditSubmissions(comboname, source=vd.reddit.redditor(comboname).submissions)
+
+
+class RedditSubmissions(Sheet):
+    guide = '''# Reddit Submissions
+
+  [:keys]Enter[/] to open sheet with comments for the current post
+  [:keys]ga[/] to add posts in this subreddit matching input'''
+
+    # source=ListingGenerator
+    rowtype='reddit posts' # rowdef: praw.Submission
+    nKeys=2
+    columns = [
+        AttrColumn('subreddit'),
+        AttrColumn('id', width=0),
+        AttrColumn('created', width=12, type=date),
+        AttrColumn('author'),
+        AttrColumn('ups', width=8, type=int),
+        AttrColumn('downs', width=8, type=int),
+        AttrColumn('num_comments', width=8, type=int),
+        AttrColumn('title', width=50),
+        AttrColumn('selftext', width=60),
+        AttrColumn('url'),
+        AttrColumn('comments', width=0),
+    ] + list(hiddenCols(post_hidden_attrs))
+
+    def iterload(self):
+        kind = 'new' # 'top'
+        f = getattr(self.source, kind, None)
+        if f:
+            yield from f(limit=10000)
+
+    def openRow(self, row):
+        return RedditComments(row.id, source=row.comments.list())
+
+
+class RedditComments(Sheet):
+    # source=list of comments
+    rowtype='comments' # rowdef: praw.Comment
+    nKeys=2
+    columns=[
+        AttrColumn('subreddit', width=0),
+        AttrColumn('id', width=0),
+        AttrColumn('ups', width=4, type=int),
+        AttrColumn('downs', width=4, type=int),
+        AttrColumn('replies', type=list),
+        AttrColumn('created', type=date),
+        AttrColumn('author'),
+        AttrColumn('depth', type=int),
+        AttrColumn('body', width=60),
+        AttrColumn('edited', width=0),
+    ] + list(hiddenCols(comment_hidden_attrs))
+
+    def iterload(self):
+        yield from self.source
+
+    def openRow(self, row):
+        return RedditComments(row.id, source=row.replies)
+
+
+class RedditGuide(RedditSubmissions):
+    guide = '''# Authenticate Reddit
+The Reddit API must be configured before use.
+
+1. Login to Reddit and go to [:underline]https://www.reddit.com/prefs/apps[/].
+2. Create a "script" app. (Use "[:underline]http://localhost:8000[/]" for the redirect uri)
+3. Add credentials to visidatarc:
+
+    options.reddit_client_id = '...'      # below the description in the upper left
+    options.reddit_client_secret = '...'
+
+## Use [:code]reddit[/] filetype for subreddits or users
+
+Multiple may be specified, joined with "+".
+
+    vd r/commandline.reddit
+    vd u/gallowboob.reddit
+    vd r/rust+golang+python.reddit
+    vd u/spez+kn0thing.reddit
+'''
+
+@SubredditSheet.api
+@asyncthread
+def addRowsFromQuery(sheet, q):
+    for r in vd.reddit.subreddits.search(q):
+        sheet.addRow(r, index=sheet.cursorRowIndex+1)
+
+
+@RedditSubmissions.api
+@asyncthread
+def addRowsFromQuery(sheet, q):
+    for r in sheet.source.search(q, limit=None):
+        sheet.addRow(r, index=sheet.cursorRowIndex+1)
+
+
+@VisiData.api
+def sysopen_subreddits(vd, *subreddits):
+    url = "https://www.reddit.com/r/"+"+".join(subreddits)
+    vd.launchBrowser(url)
+
+
+SubredditSheet.addCommand('^O', 'sysopen-subreddit', 'sysopen_subreddits(cursorRow.display_name)', 'open browser window with subreddit')
+SubredditSheet.addCommand('g^O', 'sysopen-subreddits', 'sysopen_subreddits(*(row.display_name for row in selectedRows))', 'open browser window with messages from selected subreddits')
+SubredditSheet.addCommand('g'+ENTER, 'open-subreddits', 'vd.push(openRows(selectedRows))', 'open sheet with top ~1000 submissions for each selected subreddit')
+SubredditSheet.addCommand('ga', 'add-subreddits-match', 'addRowsFromQuery(input("add subreddits matching: "))', 'add subreddits matching input by name or description')
+RedditSubmissions.addCommand('ga', 'add-submissions-match', 'addRowsFromQuery(input("add posts matching: "))', 'add posts in this subreddit matching input')
+
+vd.addMenuItems('''
+    File > Reddit > open selected subreddits > open-subreddits
+    File > Reddit > add > matching subreddits > add-subreddits-match
+    File > Reddit > add > matching submissions > add-submissions-match
+    File > Reddit > open in browser > subreddit in current row > sysopen-subreddit
+    File > Reddit > open in browser > selected subreddits > sysopen-subreddits
+''')

visidata/loaders/api_zulip.py

@@ -0,0 +1,249 @@
+import time
+
+from visidata import vd, VisiData, BaseSheet, Sheet, TextSheet, PyobjSheet
+from visidata import ItemColumn, Column, vlen, date, asyncsingle, ENTER, AttrDict
+
+vd.option('zulip_batch_size', -100, 'number of messages to fetch per call (<0 to fetch before anchor)')
+vd.option('zulip_anchor', 1000000000, 'message id to start fetching from')
+vd.option('zulip_delay_s', 0.00001, 'seconds to wait between calls (0 to stop after first)')
+vd.option('zulip_api_key', '', 'Zulip API key')
+vd.option('zulip_email', '', 'Email for use with Zulip API key')
+
+
+@VisiData.api
+def open_zulip(vd, p):
+    vd.importExternal('zulip')
+    import zulip
+
+    if not vd.options.zulip_api_key:
+        vd.warning('zulip_api_key must be set first')
+        vd.status('Enter your login email and Zulip API key (see _https://zulip.com/api/api-keys_).')
+        email = vd.input(f'Login email for {p.given}: ', record=False)
+        api_key = vd.input(f'Zulip API key: ', record=False)
+
+        vd.setPersistentOptions(zulip_email=email, zulip_api_key=api_key)
+
+    vd.z_client = zulip.Client(site=p.given, api_key=vd.options.zulip_api_key, email=vd.options.zulip_email)
+
+    return vd.subscribedStreams
+
+
+VisiData.openhttp_zulip = VisiData.open_zulip
+
+
+@VisiData.api
+def z_rpc(vd, r, result_field_name=None):
+    if r['result'] != 'success':
+        return PyobjSheet(result_field_name+'_error', source=r)
+    elif result_field_name:
+        return PyobjSheet(result_field_name, source=r[result_field_name])
+
+
+@VisiData.lazy_property
+def allStreams(vd):
+    return ZulipStreamsSheet("all_streams", zulip_func='get_streams', zulip_result_key="streams", zulip_kwargs=dict(include_public=True, include_subscribed=True))
+
+
+@VisiData.lazy_property
+def subscribedStreams(vd):
+    return ZulipStreamsSheet("subscriptions", zulip_func='get_subscriptions', zulip_result_key="subscriptions")
+
+
+@VisiData.lazy_property
+def allMessages(vd):
+    return ZulipMessagesSheet("all_messages")
+
+
+@VisiData.api
+def parseColumns(vd, fieldlist):
+    for cname in fieldlist:
+        kwargs = {}
+        while not cname[0].isalpha():
+            if cname[0] == '#': kwargs['type'] = int
+            elif cname[0] == '@': kwargs['type'] = date
+            elif cname[0] == '-': kwargs['width'] = 0
+            else: break
+            cname = cname[1:]
+        yield ItemColumn(cname, **kwargs)
+
+
+class ZulipAPISheet(Sheet):
+    zulip_func = None
+    zulip_result_key = ''
+    zulip_args = []
+    zulip_kwargs = {}
+    fields = ''
+
+    def iterload(self):
+        self.columns = []
+        for c in vd.parseColumns(self.fields.split()):
+            self.addColumn(c)
+
+        zulip_func = self.zulip_func
+        if isinstance(zulip_func, str): # allow later binding for startup perf
+            zulip_func = getattr(vd.z_client, zulip_func)
+        r = zulip_func(*self.zulip_args, **self.zulip_kwargs)
+        if r['result'] != 'success':
+            vd.push(PyobjSheet(self.zulip_result_key+'_error', source=r))
+            return
+        yield from r[self.zulip_result_key]
+
+    def addRow(self, r, **kwargs):
+        return super().addRow(AttrDict(r), **kwargs)
+
+
+class ZulipStreamsSheet(ZulipAPISheet):
+    guide = '''# Zulip Streams
+
+- `Enter` to open recent messages from the stream
+- `z Enter` to open list of topics from the stream
+'''
+    rowtype = 'streams'  # rowdef: dict of stream from server
+    fields = '-#stream_id name @date_created description -rendered_description -invite_only -is_web_public -stream_post_policy -history_public_to_subscribers -#first_message_id -#message_retention_days -is_announcement_only'
+
+    def openRow(self, r):
+        return ZulipMessagesSheet(r.name, filters=dict(stream=r.name))
+
+    def openCell(self, c, r):
+        return ZulipTopicsSheet(r.name+'_topics',
+                             zulip_func=vd.z_client.get_stream_topics,
+                             zulip_args=[r.stream_id],
+                             zulip_result_key='topics')
+
+
+class ZulipTopicsSheet(ZulipAPISheet):
+    rowtype = 'topics'  # rowdef: dict of topic from server
+    fields='name #max_id'
+    def openRow(self, r):
+        return ZulipMessagesSheet(f'{r.name}:{r.subject}', filters=dict(stream=r.name, topic=r.subject))
+
+
+class ZulipMembersSheet(ZulipAPISheet):
+    guide = '''# Zulip Members
+- `Enter` to open list of messages from this member
+'''
+    rowtype = 'members'  # rowdef: dict of member from server
+    fields = '''-#user_id full_name email timezone @date_joined -#avatar_version -is_admin -is_owner -is_guest -is_bot -#role -is_active -avatar_url -bot_type -#bot_owner_id'''
+    def openRow(self, r):
+        return ZulipMessagesSheet(r.display_recipient, filters=dict(stream=r.display_recipient))
+
+
+class ZulipMessagesSheet(Sheet):
+    guide = '''# Zulip Messages Sheet
+Loads continuously starting with most recent, until all messages have been read.
+
+- `Ctrl+C` to cancel loading.
+- `Enter` to open message in word-wrapped text sheet
+'''
+    rowtype = 'messages'  # rowdef: dict of message from server
+#    fields = ''
+    columns = [
+        ItemColumn('timestamp', type=date, fmtstr='%Y-%m-%d %H:%M'),
+        ItemColumn('sender', 'sender_full_name'),
+        ItemColumn('sender_email', width=0),
+        ItemColumn('recipient', 'display_recipient'),
+        ItemColumn('subject'),
+        ItemColumn('content'),
+        ItemColumn('client', width=0),
+        ItemColumn('reactions', type=vlen),
+        ItemColumn('submessages', type=vlen),
+        ItemColumn('flags', width=0),
+    ]
+    filters={}
+
+    @asyncsingle # kill previous thread
+    def reload(self):
+        self.rows = []
+        narrow = list(self.filters.items())
+        n = self.options.zulip_batch_size
+        req = AttrDict(
+            num_before = -n if n < 0 else 0,
+            num_after = n if n > 0 else 0,
+            anchor = self.options.zulip_anchor,
+            apply_markdown = False,
+            narrow = narrow)
+
+        while True:
+            r = vd.z_client.call_endpoint(url='messages', method='GET', request=req)
+            if r['result'] == 'success':
+                if not r['messages']: break
+                for i, msg in enumerate(r['messages']):
+                    self.addRow(msg, index=i)
+                req['anchor'] = min(msg['id'] for msg in r['messages'])-1
+                s = self.options.zulip_delay_s
+                if s <= 0:
+                    break
+                time.sleep(s)
+
+#        vd.status('finished loading, waiting for new messages')
+#        vd.z_client.call_on_each_event(self.received_event, ['message'], narrow=narrow)
+
+    def get_channel_name(self, r):
+        recp = r['display_recipient']
+        if isinstance(recp, list):  # private message
+            return '[%s]' % recp[0]['full_name']
+        else:
+            return '%s:%s' % (recp, r['subject'])
+
+    def update_message(self, msgid, content):
+        req = {
+            "message_id": msgid,
+            "content": content
+        }
+        vd.z_rpc(vd.z_client.update_message(req))
+
+    def openRow(self, r):
+        vs = TextSheet(self.get_channel_name(r), source=[r["content"]])
+        vs.options.wrap = True
+        return vs
+
+    def received_event(self, event):
+        if event['type'] == 'message':
+            self.addRow(event['message'])
+
+    def reply_message(self, msg, row):
+        recp = row['display_recipient']
+        if isinstance(recp, list):
+            for dest in recp:
+                self.send_message(msg, row['subject'], dest['email'], 'private')
+        else:
+            self.send_message(msg, row['subject'], dest, 'stream')
+
+    def send_message(self, msg, subject, dest, msgtype='stream'):
+        req = {
+            'type': msgtype,
+            'content': msg,
+            'subject': subject,
+            'to': dest,
+        }
+        r = vd.z_client.send_message(req)
+
+        if r['result'] != 'success':
+            vd.push(PyobjSheet('send_message_result', source=r))
+
+
+vd.addGlobals({
+    'ZulipMembersSheet': ZulipMembersSheet,
+    'ZulipStreamsSheet': ZulipStreamsSheet,
+    'ZulipAPISheet': ZulipAPISheet,
+    'ZulipMessagesSheet': ZulipMessagesSheet,
+})
+
+ZulipAPISheet.addCommand('', 'open-zulip-profile', 'vd.push(PyobjSheet("profile", source=z_client.get_profile()))', 'open connected user\'s profile')
+ZulipAPISheet.addCommand('', 'open-zulip-members', 'vd.push(ZulipMembersSheet("members", zulip_func=z_client.get_users, zulip_result_key="members"))', 'open list of all members')
+ZulipAPISheet.addCommand('', 'open-zulip-streams', 'vd.push(vd.allStreams)', 'open list of all streams')
+ZulipAPISheet.addCommand('', 'open-zulip-subs', 'vd.push(vd.subscribedStreams)', 'open list of subscribed streams')
+ZulipAPISheet.addCommand('', 'open-zulip-msgs', 'vd.push(vd.allMessages)', 'open list of all messages')
+
+ZulipMessagesSheet.addCommand('', 'reply-zulip-msg', 'reply_message(input(cursorRow["display_recipient"][1]["short_name"]+"> ", "message"), cursorRow)', 'reply to current topic')
+ZulipMessagesSheet.addCommand('', 'edit-zulip-msg', 'update_message(cursorRow["id"], editCell(3, cursorRowIndex))', 'edit message content')
+
+vd.addMenuItems('''
+File > Zulip > profile > open-zulip-profile
+File > Zulip > member list > open-zulip-members
+File > Zulip > streams > open-zulip-streams
+File > Zulip > subscriptions > open-zulip-subs
+File > Zulip > messages > open-zulip-subs
+File > Zulip > reply > reply-zulip-msg
+File > Zulip > edit message > edit-zulip-msg
+''')

visidata/loaders/archive.py

@@ -8,13 +8,23 @@ from visidata import vd, VisiData, asyncthread, Sheet, Progress, Menu, options
 from visidata import ColumnAttr, Column, Path
 from visidata.type_date import date
 
+@VisiData.api
+def guess_zip(vd, p):
+    if not p.is_url() and zipfile.is_zipfile(p.open_bytes()):
+        return dict(filetype='zip')
+
+@VisiData.api
+def guess_tar(vd, p):
+    if tarfile.is_tarfile(p.fp):
+        return dict(filetype='tar')
+
 @VisiData.api
 def open_zip(vd, p):
-    return vd.ZipSheet(p.name, source=p)
+    return vd.ZipSheet(p.base_stem, source=p)
 
 @VisiData.api
 def open_tar(vd, p):
-    return TarSheet(p.name, source=p)
+    return TarSheet(p.base_stem, source=p)
 
 VisiData.open_tgz = VisiData.open_tar
 VisiData.open_txz = VisiData.open_tar
@@ -37,16 +47,33 @@ class ZipSheet(Sheet):
                getter=lambda col, row: datetime.datetime(*row[0].date_time)),
     ]
     nKeys = 2
+    guide = '''# Zip Sheet
+This is a list of files contained in the zipfile {sheet.displaySource}.
+
+Once extracted, files can be loaded with `ENTER`.
+
+Commands:
+
+- `x` to extract current file to current directory
+- `gx` to extract selected files to current directory
+- `zx` to extract current file to a given pathname
+- `gzx`  to extract selected files to given directory
+
+'''
 
     def openZipFile(self, fp, *args, **kwargs):
         '''Use VisiData input to handle password-protected zip files.'''
+        if isinstance(fp, zipfile.ZipFile):
+            zip_open =  fp.open
+        elif isinstance(fp, unzip_http.RemoteZipFile):
+            zip_open = fp._open
         try:
-            return fp.open(*args, **kwargs)
+            return zip_open(*args, **kwargs)
         except RuntimeError as err:
             if 'password required' in err.args[0]:
                 pwd = vd.input(f'{args[0].filename} is encrypted, enter password: ', display=False)
-                return fp.open(*args, **kwargs, pwd=pwd.encode('utf-8'))
-            vd.error(err)
+                return zip_open(*args, **kwargs, pwd=pwd.encode('utf-8'))
+            vd.exceptionCaught(err)
 
     def openRow(self, row):
             fi, zpath = row
@@ -59,10 +86,16 @@ class ZipSheet(Sheet):
         files = []
         for row in rows:
             r, _ = row
-            if (path/r.filename).exists():
-                vd.confirm(f'{r.filename} exists, overwrite? ')  #1452
+            vd.confirmOverwrite(path/r.filename)  #1452
             self.extract_async(row)
 
+    def sysopen_row(self, row):
+        'Extract file in row to tempdir and launch $EDITOR.  Modifications will be discarded.'
+        import tempfile
+        with tempfile.TemporaryDirectory() as tempdir:
+            self.zfp.extract(member=row[0], path=tempdir)
+            vd.launchExternalEditorPath(Path(tempdir)/row[0].filename)
+
     @asyncthread
     def extract_async(self, *rows, path=None):
         'Extract rows to *path*, without confirmation.'
@@ -115,6 +148,7 @@ ZipSheet.addCommand('x', 'extract-file', 'extract(cursorRow)', 'extract current
 ZipSheet.addCommand('gx', 'extract-selected', 'extract(*onlySelectedRows)', 'extract selected files to current directory')
 ZipSheet.addCommand('zx', 'extract-file-to', 'extract(cursorRow, path=inputPath("extract to: "))', 'extract current file to given pathname')
 ZipSheet.addCommand('gzx', 'extract-selected-to', 'extract(*onlySelectedRows, path=inputPath("extract %d files to: " % nSelectedRows))', 'extract selected files to given directory')
+ZipSheet.addCommand('Ctrl+O', 'sysopen-row', 'sysopen_row(cursorRow)', 'open $EDITOR with current file (modifications will be discarded)')
 
 vd.addMenu(Menu('File', Menu('Extract',
         Menu('current file', 'extract-file'),