gistfile1.txt

Traceback (most recent call last):
  File "./hole.py", line 177, in <module>
    main()
  File "./hole.py", line 173, in main
    App(parse_args()).run()
  File "/home/prologic/.virtualenvs/hole/lib/python2.7/site-packages/circuits/core/components.py", line 125, in __init__
    self.init(*args, **kwargs)
  File "./hole.py", line 81, in init
    self.createui()
  File "./hole.py", line 101, in createui
    canvas = self.top.render(size, focus=True)
  File "/home/prologic/.virtualenvs/hole/lib/python2.7/site-packages/urwid/widget.py", line 141, in cached_render
    canv = fn(self, size, focus=focus)
  File "/home/prologic/.virtualenvs/hole/lib/python2.7/site-packages/urwid/container.py", line 1083, in render
    focus and self.focus_part == 'body')
  File "/home/prologic/.virtualenvs/hole/lib/python2.7/site-packages/urwid/widget.py", line 141, in cached_render
    canv = fn(self, size, focus=focus)
  File "/home/prologic/.virtualenvs/hole/lib/python2.7/site-packages/urwid/widget.py", line 1004, in render
    (maxcol,) = size
ValueError: too many values to unpack

hoe.py

#!/usr/bin/env python


"""Circuits Gopher Client

A circuits based Gopher Client.
"""


from os import environ
from select import select
from urlparse import urlsplit
from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser


from circuits.net.sockets import TCPClient
from circuits.net.events import connect, write
from circuits import handler, BaseComponent, Debugger, Event

from urwid.raw_display import Screen
from urwid import AttrWrap, Frame, Text


__version__ = "0.0.1"


TITLE = "Hole - {0:s}".format(__version__)


def parse_uri(uri):
    scheme, netloc, path, query, fragment = urlsplit(uri)

    if ";" in netloc:
        host, port = netloc.split(":", 1)
    else:
        host, port = netloc, 70

    query = (query and "?{}".format(query)) or ""
    fragment = (fragment and "#{}".format(fragment)) or ""

    return host, port, "{}{}{}".format(path, query, fragment)


class keypress(Event):
    """keypress Event"""


class request(Event):
    """request Event"""


class Request(object):

    def __init__(self, selector, encoding="utf-8"):
        self.selector = selector
        self.encoding = encoding

    def __repr__(self):
        return "<Request({})>".format(self.selector)

    def __unicode__(self):
        return u"{}\r\n".format(self.selector)

    def __str__(self):
        return unicode(self).encode(self.encoding)


class App(BaseComponent):

    def init(self, args):
        self.args = args

        if self.args.debug:
            Debugger().register(self)

        self.buffer = ""
        self.host, self.port, self.selector = parse_uri(self.args.uri)

        self.transport = TCPClient(channel=self.channel).register(self)

        self.createui()

    def createui(self):
        self.screen = Screen()
        self.screen.start()

        self.screen.register_palette([
            ("title", "white", "dark blue", "standout"),
            ("status", "black", "light gray", "standout"),
        ])

        self.body = Text("")
        self.title = Text(TITLE)
        self.status = Text("Status")

        self.header = AttrWrap(self.title, "title")
        self.footer = AttrWrap(self.status, "status")
        self.top = Frame(self.body, self.header, self.footer)

        size = self.screen.get_cols_rows()
        canvas = self.top.render(size, focus=True)
        self.screen.draw_screen(size, canvas)

    @handler("ready")
    def on_ready(self, client):
        self.fire(connect(self.host, self.port))

    @handler("connected")
    def on_connected(self, host, port):
        req = Request(self.selector)
        self.fire(request(req))

    @handler("closed")
    def on_closed(self):
        self.body.set_text(self.buffer)

    @handler("read")
    def on_read(self, data):
        self.buffer += data

    @handler("request")
    def on_request(self, req):
        self.fire(write(str(req)))

    @handler("stopped", channel="*")
    def on_stopped(self, component):
        self.screen.stop()

    @handler("generate_events")
    def on_generate_events(self, event):
        event.reduce_time_left(0)

        size = self.screen.get_cols_rows()

        if not select(self.screen.get_input_descriptors(), [], [], 0.1)[0] == []:
            size = self.screen.get_cols_rows()
            canvas = self.top.render(size, focus=True)
            self.screen.draw_screen(size, canvas)
            keys = self.screen.get_input()

            for k in keys:
                if k == "window resize":
                    size = self.screen.get_cols_rows()
                    continue
                else:
                    self.fire(keypress(k))

                self.top.keypress(size, k)


def parse_args():
    parser = ArgumentParser(
        description=__doc__, version=__version__,
        formatter_class=ArgumentDefaultsHelpFormatter
    )

    parser.add_argument(
        "-d", "--debug", action="store_true", dest="debug",
        default=environ.get("DEBUG", False),
        help="Enable Debug Mode"
    )

    parser.add_argument(
        "uri", action="store", metavar="URI", type=str, nargs="?",
        default=environ.get("URI", "gopher://gopher.floodgap.com"),
        help="Gopher URI to connect to"
    )

    return parser.parse_args()


def main():
    App(parse_args()).run()


if __name__ == "__main__":
    main()