def load_palette():
state.palette_entries = {}
for (n, f, b) in [
("unread", "white", "black"),
]:
state.palette_entries[n] = PaletteEntry(name=n,
mono="white",
foreground=f,
background=b,
foreground_high=f,
background_high=b)
for k, v in config.settings.profile.attributes.items():
state.palette_entries[k] = PaletteEntry.from_config(v)
for pname, p in providers.PROVIDERS.items():
if not hasattr(p.config, "attributes"):
continue
for gname, group in p.config.attributes.items():
for k, v in group.items():
ename = f"{pname}.{gname}.{k}"
state.palette_entries[ename] = PaletteEntry.from_config(v)
state.palette_entries.update(
DataTable.get_palette_entries(user_entries=state.palette_entries))
state.palette_entries.update(Dropdown.get_palette_entries())
state.palette_entries.update(ScrollingListBox.get_palette_entries())
state.palette_entries.update(TabView.get_palette_entries())
# raise Exception(state.palette_entries)
return Palette("default", **state.palette_entries)
def load_palette():
state.palette_entries = {}
for k, v in config.settings.profile.attributes.items():
state.palette_entries[k] = PaletteEntry.from_config(v)
for pname, p in providers.PROVIDERS.items():
if not hasattr(p.config, "attributes"):
continue
for gname, group in p.config.attributes.items():
for k, v in group.items():
ename = f"{pname}.{gname}.{k}"
state.palette_entries[ename] = PaletteEntry.from_config(v)
state.palette_entries.update(
DataTable.get_palette_entries(user_entries=state.palette_entries))
state.palette_entries.update(Dropdown.get_palette_entries())
state.palette_entries.update(ScrollingListBox.get_palette_entries())
state.palette_entries.update(TabView.get_palette_entries())
state.palette_entries.update(sparkwidgets.get_palette_entries())
# raise Exception(state.palette_entries)
return Palette("default", **state.palette_entries)
def main():
global options
global logger
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", action="store_true")
options, args = parser.parse_known_args()
log_file = os.path.join(config.CONFIG_DIR, "mlbstreamer.log")
formatter = logging.Formatter(
"%(asctime)s [%(module)16s:%(lineno)-4d] [%(levelname)8s] %(message)s",
datefmt="%Y-%m-%d %H:%M:%S"
)
fh = logging.FileHandler(log_file)
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
logger = logging.getLogger("mlbstreamer")
logger.setLevel(logging.INFO)
logger.addHandler(fh)
ulh = UrwidLoggingHandler()
ulh.setLevel(logging.DEBUG)
ulh.setFormatter(formatter)
logger.addHandler(ulh)
logger.debug("mlbstreamer starting")
config.settings.load()
state.session = MLBSession.new()
entries = Dropdown.get_palette_entries()
entries.update(ScrollingListBox.get_palette_entries())
entries.update(DataTable.get_palette_entries())
# raise Exception(entries)
palette = Palette("default", **entries)
screen = urwid.raw_display.Screen()
screen.set_terminal_properties(256)
view = ScheduleView()
log_console = widgets.ConsoleWindow()
# log_box = urwid.BoxAdapter(urwid.LineBox(log_console), 10)
pile = urwid.Pile([
("weight", 1, urwid.LineBox(view)),
(10, urwid.LineBox(log_console))
])
def global_input(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
else:
return False
state.loop = urwid.MainLoop(
pile,
palette,
screen=screen,
unhandled_input=global_input,
pop_ups=True
)
ulh.connect(state.loop.watch_pipe(log_console.log_message))
logger.info("mlbstreamer starting")
if options.verbose:
logger.setLevel(logging.DEBUG)
state.loop.run()
def main():
parser = OptionParser()
parser.add_option("-v", "--verbose", action="count", default=0),
(options, args) = parser.parse_args()
if options.verbose:
formatter = logging.Formatter(
"%(asctime)s [%(levelname)8s] %(message)s",
datefmt='%Y-%m-%d %H:%M:%S')
fh = logging.FileHandler("datatable.log")
# fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
if options.verbose > 1:
logger.setLevel(logging.DEBUG)
logging.getLogger("panwid.datatable").setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
logging.getLogger("panwid.datatable").setLevel(logging.INFO)
logger.addHandler(fh)
logging.getLogger("panwid.datatable").addHandler(fh)
# logging.getLogger("raccoon.dataframe").setLevel(logging.DEBUG)
# logging.getLogger("raccoon.dataframe").addHandler(fh)
attr_entries = {}
for attr in ["dark red", "dark green", "dark blue"]:
attr_entries[attr.split()[1]] = PaletteEntry(mono="white",
foreground=attr,
background="black")
entries = ScrollingListBox.get_palette_entries()
entries.update(DataTable.get_palette_entries(user_entries=attr_entries))
palette = Palette("default", **entries)
COLUMNS = [
# DataTableColumn("uniqueid", width=10, align="right", padding=1),
DataTableColumn(
"foo",
label="Foo",
width=5,
align="right",
sort_key=lambda v: (v is None, v),
attr="color",
padding=0,
footer_fn=lambda column, values: sum(v for v in values
if v is not None)),
DataTableColumn("bar",
label="Bar",
width=10,
align="right",
sort_reverse=True,
sort_icon=False,
padding=1), # margin=5),
DataTableColumn("baz", label="Baz!", width=("weight", 1)),
DataTableColumn("qux",
label=urwid.Text([("red", "q"), ("green", "u"),
("blue", "x")]),
width=5,
hide=True),
# DataTableColumn("empty", label="empty", width=5),
]
class ExampleDataTable(DataTable):
columns = COLUMNS[:]
index = "index"
def __init__(self, num_rows=10, *args, **kwargs):
self.num_rows = num_rows
# indexes = random.sample(range(self.num_rows*2), num_rows)
self.randomize_query_data()
self.last_rec = len(self.query_data)
super(ExampleDataTable, self).__init__(*args, **kwargs)
def randomize_query_data(self):
indexes = list(range(self.num_rows))
self.query_data = [
self.random_row(indexes[i]) for i in range(self.num_rows)
# self.random_row(i) for i in range(self.num_rows)
]
random.shuffle(self.query_data)
def random_row(self, uniqueid):
return dict(
uniqueid=uniqueid,
foo=random.choice(list(range(100)) + [None] * 20),
bar=(random.uniform(0, 1000)
if random.randint(0, 5) else None),
baz=(''.join(
random.choice(string.ascii_uppercase +
string.ascii_lowercase + string.digits +
' ' * 10)
for _ in range(random.randint(5, 20))) if random.randint(
0, 5) else None),
qux=urwid.Text([("red", "1"), ("green", "2"), ("blue", "3")]),
xyzzy=("%0.1f" % (random.uniform(0, 100)) if random.randint(
0, 5) else None),
baz_len=lambda r: len(r["baz"]) if r.get("baz") else 0,
# xyzzy = random.randint(10, 100),
empty=None,
a=dict(b=dict(c=random.randint(0, 100))),
d=dict(e=dict(f=random.randint(0, 100))),
color=["red", "green", "blue"][random.randrange(3)],
)
def query(self,
sort=(None, None),
offset=None,
limit=None,
load_all=False):
logger.info("query: offset=%s, limit=%s, sort=%s" %
(offset, limit, sort))
try:
sort_field, sort_reverse = sort
except:
sort_field = sort
sort_reverse = None
if sort_field:
kwargs = {}
kwargs["key"] = lambda x: (x.get(
sort_field) is None, x.get(sort_field), x.get(self.index))
if sort_reverse:
kwargs["reverse"] = sort_reverse
self.query_data.sort(**kwargs)
if offset is not None:
if not load_all:
start = offset
end = offset + limit
r = self.query_data[start:end]
logger.debug("%s:%s (%s)" % (start, end, len(r)))
else:
r = self.query_data[offset:]
else:
r = self.query_data
for d in r:
yield d
def query_result_count(self):
return self.num_rows
def keypress(self, size, key):
if key == "meta r":
self.randomize_query_data()
self.reset(reset_sort=True)
if key == "ctrl r":
self.reset(reset_sort=True)
if key == "ctrl d":
self.log_dump(20)
if key == "meta d":
self.log_dump(20, columns=["foo", "baz"])
if key == "ctrl f":
self.focus_position = 0
elif key == "ctrl t":
# logger.info(self.get_row(0)[0])
logger.info(self.selection.data["bar"])
elif key == "meta i":
logger.info(
"foo %s, baz: %s" %
(self.selection.get("foo"), self.selection.get("baz")))
elif self.ui_sort and key.isdigit() and int(key) - 1 in range(
len(self.columns)):
col = int(key) - 1
self.sort_by_column(col, toggle=True)
elif key == "ctrl l":
self.load("test.json")
elif key == "ctrl s":
self.save("test.json")
elif key == "0":
# self.sort_by_column(self.index, toggle=True)
self.sort_index()
elif key == "a":
self.add_row(self.random_row(self.last_rec))
self.last_rec += 1
elif key == "A":
self.add_row(self.random_row(self.last_rec), sort=False)
self.last_rec += 1
elif key == "d":
if len(self):
self.delete_rows(self.df.index[self.focus_position])
elif key == "meta a":
name = "".join(
random.choice(string.ascii_uppercase + string.lowercase +
string.digits) for _ in range(5))
data = [
"".join(
random.choice(string.ascii_uppercase +
string.lowercase + string.digits)
for _ in range(5)) for _ in range(len(self))
]
col = DataTableColumn(name, label=name, width=6, padding=0)
self.add_columns(col, data=data)
elif key == "r":
self.set_columns(COLUMNS)
elif key == "t":
self.toggle_columns("qux")
elif key == "T":
self.toggle_columns(["foo", "baz"])
elif key == "D":
self.remove_columns(len(self.columns) - 1)
elif key == "f":
self.apply_filters(
[lambda x: x["foo"] > 20, lambda x: x["bar"] < 800])
elif key == "F":
self.clear_filters()
elif key == ".":
self.toggle_details()
elif key == "s":
self.selection.set_attr("red")
elif key == "S":
self.selection.clear_attr("red")
elif key == "k":
self.selection[2].set_attr("red")
elif key == "K":
self.selection[2].clear_attr("red")
elif key == "u":
logger.info(self.footer.values)
elif key == "c":
self.toggle_cell_selection()
elif key == "shift left":
self.cycle_sort_column(-1)
elif key == "shift right":
self.cycle_sort_column(1)
elif self.ui_sort and key == "shift up":
self.sort_by_column(reverse=True)
elif self.ui_sort and key == "shift down":
self.sort_by_column(reverse=False)
elif key == "shift end":
self.load_all()
# self.listbox.focus_position = len(self) -1
elif key == "ctrl up":
if self.focus_position > 0:
self.swap_rows(self.focus_position,
self.focus_position - 1, "foo")
self.focus_position -= 1
elif key == "ctrl down":
if self.focus_position < len(self) - 1:
self.swap_rows(self.focus_position,
self.focus_position + 1, "foo")
self.focus_position += 1
else:
return super(ExampleDataTable, self).keypress(size, key)
class ExampleDataTableBox(urwid.WidgetWrap):
def __init__(self, *args, **kwargs):
self.table = ExampleDataTable(*args, **kwargs)
urwid.connect_signal(
self.table, "select",
lambda source, selection: logger.info("selection: %s" %
(selection)))
label = "sz:%d pgsz:%s sort:%s%s hdr:%s ftr:%s ui_sort:%s cell_sel:%s" % (
self.table.query_result_count(),
self.table.limit if self.table.limit else "-",
"-" if self.table.sort_by[1] else
"+" if self.table.sort_by[0] else "n",
self.table.sort_by[0] or " ",
"y" if self.table.with_header else "n",
"y" if self.table.with_footer else "n",
"y" if self.table.ui_sort else "n",
"y" if self.table.cell_selection else "n",
)
self.pile = urwid.Pile([("pack", urwid.Text(label)),
("pack",
urwid.Divider(u"\N{HORIZONTAL BAR}")),
("weight", 1, self.table)])
self.box = urwid.BoxAdapter(urwid.LineBox(self.pile), 25)
super(ExampleDataTableBox, self).__init__(self.box)
def detail_fn(data):
return urwid.Padding(
urwid.Columns([
("weight", 1, data.get("qux")),
("weight", 1, urwid.Text(str(data.get("baz_len")))),
("weight", 2, urwid.Text(str(data.get("xyzzy")))),
]))
boxes = [
ExampleDataTableBox(10,
index="uniqueid",
detail_fn=detail_fn,
detail_column="bar",
cell_selection=True,
sort_refocus=True),
ExampleDataTableBox(
1000,
index="uniqueid",
sort_by="foo",
query_sort=False,
ui_sort=False,
with_footer=True,
with_scrollbar=True,
),
ExampleDataTableBox(
500,
columns=[
DataTableColumn("row", width=7, value="{row}/{rows_total}")
] + ExampleDataTable.columns,
limit=25,
index="uniqueid",
sort_by=("bar", True),
sort_icons=False,
query_sort=True,
with_footer=True,
with_scrollbar=True,
cell_selection=True,
border=(1, u"\N{VERTICAL LINE}", "blue"),
padding=3,
),
ExampleDataTableBox(
5000,
limit=500,
index="uniqueid",
sort_by=("foo", True),
border=3,
query_sort=True,
with_scrollbar=True,
with_header=False,
with_footer=False,
),
]
grid_flow = urwid.GridFlow(boxes, 60, 1, 1, "left")
def global_input(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
else:
return False
old_signal_keys = screen.tty_signal_keys()
l = list(old_signal_keys)
l[0] = 'undefined'
l[3] = 'undefined'
l[4] = 'undefined'
screen.tty_signal_keys(*l)
main = urwid.MainLoop(urwid.Frame(
urwid.Filler(urwid.LineBox(grid_flow), valign="top")),
palette=palette,
screen=screen,
unhandled_input=global_input)
try:
main.run()
finally:
screen.tty_signal_keys(*old_signal_keys)
def main():
os.system('echo "Running git fetch" && git fetch')
os.system('echo "Running git fetcth upstream" && git fetch upstream')
logger = logging.getLogger(__name__)
parser = OptionParser()
parser.add_option("-d",
"--dir",
dest="dir",
help="git repo dir",
metavar="DIR")
parser.add_option("-v", "--verbose", action="count", default=0),
parser.add_option("-e",
"--environment",
action="append",
dest="environments"),
parser.add_option('-D', '--debug', action="store_true", default=True)
(options, args) = parser.parse_args()
os.chdir(options.dir)
envs = options.environments if options.environments is not None else []
model = init_settings()
main_branch, dev_branch, stage_names, stage_shortnames = model
stage_names, stage_data, filepaths = analyze_changes(
main_branch, dev_branch, stage_names)
def map_version_to_tag(version):
if version.startswith('v'):
return version[1:]
return version
environment__version = build__environment__version(envs,
map_version_to_tag)
version__environments = invert_dict(environment__version)
version__commit = build__version__commit(environment__version)
commit__versions = invert_dict(version__commit)
last_prod_version = stage_data['in_last_production_release'][
'version_number']
prev_prod_version = stage_data['in_previous_production_release'][
'version_number']
if options.debug:
for s in stage_names:
for k, v in stage_data[s].items():
if k == 'commits':
pass # for commit in v:
# print('Stage: ' + stage_shortnames[s] + ': ' + commit)
elif k == 'filepaths':
if options.verbose:
for filepath in v:
print('Stage: ' + stage_shortnames[s] + ': ' +
filepath)
print('Stage {}: {} files modified.'.format(
stage_shortnames[s], len(v)))
# sys.exit(2)
if options.verbose:
formatter = logging.Formatter(
"%(asctime)s [%(levelname)8s] %(message)s",
datefmt='%Y-%m-%d %H:%M:%S')
fh = logging.FileHandler("datatable.log")
# fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
if options.verbose > 1:
logger.setLevel(logging.DEBUG)
logging.getLogger("panwid.datatable").setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
logging.getLogger("panwid.datatable").setLevel(logging.INFO)
logger.addHandler(fh)
logging.getLogger("panwid.datatable").addHandler(fh)
# logging.getLogger("raccoon.dataframe").setLevel(logging.DEBUG)
# logging.getLogger("raccoon.dataframe").addHandler(fh)
attr_entries = {}
for attr in ["dark red", "dark green", "dark blue"]:
attr_entries[attr.split()[1]] = PaletteEntry(mono="white",
foreground=attr,
background="black")
entries = ScrollingListBox.get_palette_entries()
entries.update(DataTable.get_palette_entries(user_entries=attr_entries))
palette = Palette("default", **entries)
screen = urwid.raw_display.Screen()
# screen.set_terminal_properties(1<<24)
screen.set_terminal_properties(256)
NORMAL_FG_MONO = "white"
NORMAL_FG_16 = "light gray"
NORMAL_BG_16 = "black"
NORMAL_FG_256 = "light gray"
NORMAL_BG_256 = "g0"
def env_matcher(stage):
return get_possible_matching_envs(environment__version,
version__environments,
commit__versions, stage_data[stage],
None)
e1 = env_matcher('in_previous_production_release')
e2 = env_matcher('in_last_production_release')
e3 = env_matcher('pushed_but_not_merged')
e4 = env_matcher('in_merged_prs_not_released')
COLUMNS = [
# DataTableColumn("uniqueid", width=10, align="right", padding=1),
DataTableColumn("file", label="File", width=78),
DataTableColumn(
"unstaged",
label=stage_shortnames['unstaged'],
width=10,
align="right",
sort_key=lambda v: (v is None, v),
attr="color",
padding=0,
footer_fn=lambda column, values: sum(v for v in values
if v is not None)),
DataTableColumn("staged",
label=stage_shortnames['staged'],
width=10,
align="right",
sort_reverse=True,
sort_icon=False,
padding=1), # margin=5),
DataTableColumn("in_commits_but_not_pushed",
label=stage_shortnames['in_commits_but_not_pushed'],
width=10,
align="right",
sort_reverse=True,
sort_icon=False,
padding=1), # margin=5),
DataTableColumn("pushed_but_not_merged",
label=stage_shortnames['pushed_but_not_merged'] + e3,
width=10,
align="right",
sort_reverse=True,
sort_icon=False,
padding=1), # margin=5),
DataTableColumn("in_merged_prs_not_released",
label=stage_shortnames['in_merged_prs_not_released'] +
e4,
width=10,
align="right",
sort_reverse=True,
sort_icon=False,
padding=1), # margin=5),
DataTableColumn("in_last_production_release",
label=stage_shortnames['in_last_production_release'] +
' ' + last_prod_version + e2,
width=10,
align="right",
sort_reverse=True,
sort_icon=False,
padding=1), # margin=5),
DataTableColumn(
"in_previous_production_release",
label=stage_shortnames['in_previous_production_release'] + ' ' +
prev_prod_version + e1,
width=10,
align="right",
sort_reverse=True,
sort_icon=False,
padding=1), # margin=5),
DataTableColumn("qux",
label=urwid.Text([("red", "q"), ("green", "u"),
("blue", "x")]),
width=5,
hide=True),
# DataTableColumn("empty", label="empty", width=5),
]
def detail_fn(data):
return urwid.Padding(
urwid.Columns([
("weight", 1, data.get("qux")),
("weight", 1, urwid.Text(str(data.get("file_len")))),
("weight", 1, urwid.Text(str(data.get("xyzzy")))),
]))
grtb = GitRadarTableBox(
COLUMNS,
logger,
model,
33,
index="uniqueid",
detail_fn=detail_fn,
# detail_column="staged", outcommented by Ville 2020/09
cell_selection=True,
sort_refocus=True,
sort_by="file")
boxes = [grtb]
grid_flow = urwid.GridFlow(boxes, 300, 1, 1, "left")
def global_input(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
else:
return False
old_signal_keys = screen.tty_signal_keys()
undef = list(old_signal_keys)
undef[0] = 'undefined'
undef[3] = 'undefined'
undef[4] = 'undefined'
# Outcommenting tty_signal_keys call that fails with recent Python 3.8 urwid-2.1.1
# TypeError: tcsetattr: elements of attributes must be characters or integers
#
# screen.tty_signal_keys(undef)
main_frame = urwid.Frame(
urwid.Filler(urwid.LineBox(grid_flow), valign="top"))
main = urwid.MainLoop(main_frame,
palette=palette,
screen=screen,
unhandled_input=global_input)
try:
grtb.loop = main
grtb._body = main_frame
main.run()
finally:
screen.tty_signal_keys(*old_signal_keys)
def main():
global options
global logger
today = datetime.now(pytz.timezone('US/Eastern')).date()
init_parser = argparse.ArgumentParser()
init_parser.add_argument("-p",
"--profile",
help="use alternate config profile")
options, args = init_parser.parse_known_args()
config.settings.load()
if options.profile:
config.settings.set_profile(options.profile)
parser = argparse.ArgumentParser()
# parser.add_argument("-d", "--date", help="game date",
# type=utils.valid_date,
# default=today)
parser.add_argument("-r",
"--resolution",
help="stream resolution",
default=config.settings.profile.default_resolution)
group = parser.add_mutually_exclusive_group()
group.add_argument("-v",
"--verbose",
action="count",
default=0,
help="verbose logging")
group.add_argument("-q",
"--quiet",
action="count",
default=0,
help="quiet logging")
parser.add_argument("game",
metavar="game",
help="game specifier",
nargs="?")
options, args = parser.parse_known_args()
log_file = os.path.join(config.CONFIG_DIR, "mlbstreamer.log")
# formatter = logging.Formatter(
# "%(asctime)s [%(module)16s:%(lineno)-4d] [%(levelname)8s] %(message)s",
# datefmt="%Y-%m-%d %H:%M:%S"
# )
fh = logging.FileHandler(log_file)
fh.setLevel(logging.DEBUG)
# fh.setFormatter(formatter)
logger = logging.getLogger("mlbstreamer")
# logger.setLevel(logging.INFO)
# logger.addHandler(fh)
ulh = UrwidLoggingHandler()
# ulh.setLevel(logging.DEBUG)
# ulh.setFormatter(formatter)
# logger.addHandler(ulh)
utils.setup_logging(options.verbose - options.quiet,
handlers=[fh, ulh],
quiet_stdout=True)
try:
(provider, game_date) = options.game.split("/", 1)
except (ValueError, AttributeError):
if options.game in session.PROVIDERS:
provider = options.game
game_date = datetime.now().date()
else:
provider = list(config.settings.profile.providers.keys())[0]
game_date = dateutil.parser.parse(options.game)
logger.debug("mlbstreamer starting")
entries = Dropdown.get_palette_entries()
entries.update(ScrollingListBox.get_palette_entries())
entries.update(DataTable.get_palette_entries())
# raise Exception(entries)
palette = Palette("default", **entries)
screen = urwid.raw_display.Screen()
screen.set_terminal_properties(256)
view = ScheduleView(provider, game_date)
log_console = widgets.ConsoleWindow()
# log_box = urwid.BoxAdapter(urwid.LineBox(log_console), 10)
pile = urwid.Pile([("weight", 5, urwid.LineBox(view)),
("weight", 1, urwid.LineBox(log_console))])
def global_input(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
else:
return False
state.loop = urwid.MainLoop(pile,
palette,
screen=screen,
unhandled_input=global_input,
pop_ups=True)
ulh.connect(state.loop.watch_pipe(log_console.log_message))
logger.info("mlbstreamer starting")
if options.verbose:
logger.setLevel(logging.DEBUG)
state.loop.run()