#########

# GLOBALS

#########

import os

import sys

import shutil

import yaml

import urwid

from urwid.widget import BOX, FLOW, FIXED

#########

# HELPERS

#########

CURR_DIR = os.path.dirname(os.path.realpath(__file__))

is_not_dumb = os.getenv("TERM", "dumb").lower() != "dumb"

# Scroll actions

SCROLL_LINE_UP = "line up"

SCROLL_LINE_DOWN = "line down"

SCROLL_PAGE_UP = "page up"

SCROLL_PAGE_DOWN = "page down"

SCROLL_TO_TOP = "to top"

SCROLL_TO_END = "to end"

# ASCII color codes

YELLOW = '\033[33m' if is_not_dumb else ''

RED = "\033[31m" if is_not_dumb else ''

BOLD = '\033[1m' if is_not_dumb else ''

UNDERLINE = '\033[4m' if is_not_dumb else ''

END = "\033[0m" if is_not_dumb else ''

class Scrollable(urwid.WidgetDecoration):

# TODO: Fix scrolling behavior (works with up/down keys, not with cursor) <--- Now works with mouse though

def sizing(self):

return frozenset([BOX])

def selectable(self):

return True

def __init__(self, widget):

"""

Box widget (wrapper) that makes a fixed or flow widget vertically scrollable.

"""

self._trim_top = 0

self._scroll_action = None

self._forward_keypress = None

self._old_cursor_coords = None

self._rows_max_cached = 0

self.__super.__init__(widget)

def render(self, size, focus=False):

maxcol, maxrow = size

# Render complete original widget

ow = self._original_widget

ow_size = self._get_original_widget_size(size)

canv = urwid.CompositeCanvas(ow.render(ow_size, focus))

canv_cols, canv_rows = canv.cols(), canv.rows()

if canv_cols <= maxcol:

pad_width = maxcol - canv_cols

if pad_width > 0: # Canvas is narrower than available horizontal space

canv.pad_trim_left_right(0, pad_width)

if canv_rows <= maxrow:

fill_height = maxrow - canv_rows

if fill_height > 0: # Canvas is lower than available vertical space

canv.pad_trim_top_bottom(0, fill_height)

if canv_cols <= maxcol and canv_rows <= maxrow: # Canvas is small enough to fit without trimming

return canv

self._adjust_trim_top(canv, size)

# Trim canvas if necessary

trim_top = self._trim_top

trim_end = canv_rows - maxrow - trim_top

trim_right = canv_cols - maxcol

if trim_top > 0:

canv.trim(trim_top)

if trim_end > 0:

canv.trim_end(trim_end)

if trim_right > 0:

canv.pad_trim_left_right(0, -trim_right)

# Disable cursor display if cursor is outside of visible canvas parts

if canv.cursor is not None:

curscol, cursrow = canv.cursor

if cursrow >= maxrow or cursrow < 0:

canv.cursor = None

# Let keypress() know if original_widget should get keys

self._forward_keypress = bool(canv.cursor)

return canv

def mouse_event(self, size, event, button, col, row, focus):

if 'press' in event.split(' '):

if button in (4,5):

self.keypress(size, SCROLL_PAGE_DOWN if button == 5 else SCROLL_PAGE_UP)

def keypress(self, size, key):

if self._forward_keypress:

ow = self._original_widget

ow_size = self._get_original_widget_size(size)

# Remember previous cursor position if possible

if hasattr(ow, "get_cursor_coords"):

self._old_cursor_coords = ow.get_cursor_coords(ow_size)

key = ow.keypress(ow_size, key)

if key is None:

return None

# Handle up/down, page up/down, etc

command_map = self._command_map

if command_map[key] == urwid.CURSOR_UP:

self._scroll_action = SCROLL_LINE_UP

elif command_map[key] == urwid.CURSOR_DOWN:

self._scroll_action = SCROLL_LINE_DOWN

elif command_map[key] == urwid.CURSOR_PAGE_UP:

self._scroll_action = SCROLL_PAGE_UP

elif command_map[key] == urwid.CURSOR_PAGE_DOWN:

self._scroll_action = SCROLL_PAGE_DOWN

elif command_map[key] == urwid.CURSOR_MAX_LEFT: # "home"

self._scroll_action = SCROLL_TO_TOP

elif command_map[key] == urwid.CURSOR_MAX_RIGHT: # "end"

self._scroll_action = SCROLL_TO_END

else:

return key

self._invalidate()

def mouse_event(self, size, event, button, col, row, focus):

ow = self._original_widget

if hasattr(ow, "mouse_event"):

ow_size = self._get_original_widget_size(size)

row += self._trim_top

return ow.mouse_event(ow_size, event, button, col, row, focus)

else:

return False

def _adjust_trim_top(self, canv, size):

"""

Adjust self._trim_top according to self._scroll_action

"""

action = self._scroll_action

self._scroll_action = None

maxcol, maxrow = size

trim_top = self._trim_top

canv_rows = canv.rows()

if trim_top < 0:

# Negative trim_top values use bottom of canvas as reference

trim_top = canv_rows - maxrow + trim_top + 1

if canv_rows <= maxrow:

self._trim_top = 0 # Reset scroll position

return

def ensure_bounds(new_trim_top):

return max(0, min(canv_rows - maxrow, new_trim_top))

if action == SCROLL_LINE_UP:

self._trim_top = ensure_bounds(trim_top - 1)

elif action == SCROLL_LINE_DOWN:

self._trim_top = ensure_bounds(trim_top + 1)

elif action == SCROLL_PAGE_UP:

self._trim_top = ensure_bounds(trim_top - maxrow + 1)

elif action == SCROLL_PAGE_DOWN:

self._trim_top = ensure_bounds(trim_top + maxrow - 1)

elif action == SCROLL_TO_TOP:

self._trim_top = 0

elif action == SCROLL_TO_END:

self._trim_top = canv_rows - maxrow

else:

self._trim_top = ensure_bounds(trim_top)

if self._old_cursor_coords is not None and self._old_cursor_coords != canv.cursor:

self._old_cursor_coords = None

curscol, cursrow = canv.cursor

if cursrow < self._trim_top:

self._trim_top = cursrow

elif cursrow >= self._trim_top + maxrow:

self._trim_top = max(0, cursrow - maxrow + 1)

def _get_original_widget_size(self, size):

ow = self._original_widget

sizing = ow.sizing()

if FIXED in sizing:

return ()

elif FLOW in sizing:

return size[0],

def get_scrollpos(self, size=None, focus=False):

return self._trim_top

def set_scrollpos(self, position):

self._trim_top = int(position)

self._invalidate()

def rows_max(self, size=None, focus=False):

if size is not None:

ow = self._original_widget

ow_size = self._get_original_widget_size(size)

sizing = ow.sizing()

if FIXED in sizing:

self._rows_max_cached = ow.pack(ow_size, focus)[1]

elif FLOW in sizing:

self._rows_max_cached = ow.rows(ow_size, focus)

else:

raise RuntimeError("Not a flow/box widget: %r" % self._original_widget)

return self._rows_max_cached

class App(object):

def __init__(self, content):

self._palette = [

("menu", "black", "light cyan", "standout"),

("title", "default,bold", "default", "bold")

]

menu = urwid.Text([u'\n', ("menu", u" Q "), ("light gray", u" Quit")]) # TODO: Make like man pages (vim input)

layout = urwid.Frame(body=content, footer=menu)

main_loop = urwid.MainLoop(layout, self._palette, unhandled_input=App._handle_input, handle_mouse=True)

main_loop.run()

@staticmethod

def _handle_input(inp):

if inp in ('q', 'Q'):

raise urwid.ExitMainLoop()

def output_without_ui(content):

size = shutil.get_terminal_size()

canvas = content.render(size)

text = ("\n".join(text.decode("utf-8") for text in canvas.text)).rstrip()

print(text)

def generate_content(status_code):

try:

code_descriptions, num, status_code = get_yaml_dictionary(status_code)

content = code_descriptions[status_code]

pile = urwid.Pile([

urwid.Text("STATCODE: The Manual for HTTP Status Codes and Headers\n", align="center"),

urwid.Text(("title", "STATUS MESSAGE" if num else "HEADER INFO")),

urwid.Padding(

urwid.Text(''.join([str(status_code), ": " if num else ", Example= ", content["message"], '\n'])),

left=5),

urwid.Text(("title", "CATEGORY")),

urwid.Padding(urwid.Text(''.join([content["category"], '\n'])), left=5),

urwid.Text(("title", "DESCRIPTION")),

urwid.Padding(urwid.Text(''.join([content["description"], '\n'])), left=5),

urwid.Text(("title", "COPYRIGHT")),

urwid.Padding(urwid.Text(''.join([__load_file_data(num), '\n'])), left=5),

])

padding = urwid.Padding(Scrollable(pile), left=1, right=1)

return padding

except KeyError: # None is used to print "not recognized", so KeyError. Other errors have nothing to do with it

return None

def __load_file_data(num):

copyleft = yaml.safe_load(open('/'.join([CURR_DIR, "copyright_description.yml"]), 'r'))

if num:

return copyleft['statuscode']

else:

return copyleft['headers']

def get_yaml_dictionary(status_code):

try:

status_code = int(status_code)

num = True

filename = "code_descriptions.yml"

except (TypeError, ValueError):

num = False

filename = "header_descriptions.yml"

try:

code_descriptions = yaml.safe_load(

open('/'.join([CURR_DIR, filename]), 'r'))

except yaml.constructor.ConstructorError:

print("Invalid file. Only support valid json and yaml files.")

sys.exit(1)

return code_descriptions, num, status_code

def print_help():

print(''.join([BOLD, "statcode v1.0.0 – Made by @shobrook", END, '\n']))

print("Like man pages, but for HTTP status codes.\n")

print(''.join([UNDERLINE, "Usage:", END, " $ statcode ", YELLOW, "status_code", END]))

print(''.join([BOLD, "-h, --help:", END, " prints this help"]))

print(''.join([BOLD, "-a,-l, --all,--list statucode", END, " prints all codes in compact version"]))

print(''.join([BOLD, "-a,-l, --all,--list headers", END, " prints all headers in compact version"]))

print(''.join([BOLD, "-n, --no-ui", END, " force output without UI"]))

def print_all(status_code):

if status_code == "statuscode":

code_descriptions, num, status_code = get_yaml_dictionary(200)

else:

code_descriptions, num, status_code = get_yaml_dictionary("Accept")

del status_code

for k, v in code_descriptions.items():

print(''.join([RED, str(k), ':', END, " ", v["message"] if num else ""]))

######

# MAIN

######

def main():

if len(sys.argv) == 1 or sys.argv[1].lower() in ("-h", "--help"):

print_help()

elif sys.argv[1].lower() in ("-a", "-l", "--all", "--list"):

try:

status_code = sys.argv[2]

if status_code not in ("statuscode", "headers"):

print(''.join([BOLD, "Wrong parameter for this usage, see help", END]))

return

print_all(status_code)

except IndexError:

print_help()

else:

status_code = sys.argv[1]

without_ui = len(sys.argv) > 2 and sys.argv[2].lower() in ("-n", "--no-ui")

content = generate_content(status_code)

if content:

if without_ui or not is_not_dumb:

output_without_ui(content)

else:

try:

App(content) # Opens interface

except NameError:

output_without_ui(content)

else:

print(''.join([RED, "Sorry, statcode doesn't recognize: ", status_code, END]))

return