def _print_conn_metrics(
conn, metrics, height=1, prefix="", auto_yaxis=True, file=sys.stdout
):
colors = [Fore.RED, Fore.CYAN, Fore.CYAN]
for name, get_values in metrics.items():
values = [value for timestamp, value in get_values()]
if name == "ConnectionState":
max_yaxis = 1
elif auto_yaxis:
max_yaxis = None
else:
max_yaxis = bps(conn["bandwidth"])
if height == 1:
chart = sparkify(values, minimum=0, maximum=max_yaxis)
print(prefix, end=" ", file=file)
elif height > 1:
opts = {
"minimum": 0,
"height": height,
"format": "{:14,.0f} ",
}
# The asciichartpy module is a bit wonky and not really idiomatic
# python as they just pass a giant dictionary of options (typical of
# javascript land). Do not provide a "maximum" key with a value of
# None. If use wants auto-scaling, don't provide the key at all.
if max_yaxis is not None:
opts["maximum"] = max_yaxis
chart = plot(values, opts)
print(_format_metric(name, chart, color=colors.pop()), file=file)
print(file=file)
def get_risk_graph(id: str) -> None:
"""Prints a graph of an extension's risk scores over time.
Args:
id: An extension identifier string.
Returns:
None.
"""
results = get_report(id)
if len(results) == 0:
error(f"No results were found for {id}.", True)
data = []
for item in results:
data.append(item["data"]["risk"]["total"])
print(
asciichartpy.plot(
data,
{
"min": min(data) - 5,
"max": max(data) + 5,
"height": 25,
"format": "{:8.0f}",
},
))
def main():
final_games = []
archives = get_archives()
for archive in archives:
final_games += get_filtered_games(archive)
if len(final_games) >= NGAMES:
break
final_games = final_games[:NGAMES]
ratings_list = get_ratings_from_games(final_games)
return (ac.plot(ratings_list, {'height': 15}))
def gui(self, scr):
scr.clear()
rows, columns = os.popen('stty size', 'r').read().split()
rows = int(rows)
columns = int(columns)
plot_width = int(columns * 0.8)
deque_dir = collections.deque([0] * plot_width, maxlen=plot_width)
deque_speed = collections.deque([0] * plot_width, maxlen=plot_width)
while (True):
value = self.tmp.value * 5.0
direction = self.map_direction(value)
deque_dir.popleft()
deque_speed.popleft()
deque_dir.append(direction)
deque_speed.append(self.speed)
scr.addstr(0, 0, 'DIRECTION')
scr.addstr(
2, 0,
plot(deque_dir, {
'minimum': 0.0,
'maximum': 360.0,
'height': 16
}))
scr.addstr(20, 0, 'SPEED')
scr.addstr(
22, 0,
plot(deque_speed, {
'minimum': 0.0,
'maximum': 20,
'height': 20
}))
scr.refresh()
publish.single(self.mqtt_path,
self.build_json_package(direction, self.speed),
hostname=self.mqtt_server)
sleep(self.send_sleep)
def cli_mem_chart(self, *args):
"""Output memory consumption chart"""
# Subtract 11 columns for the chart axis
width = shutil.get_terminal_size().columns - 11
config = {
'colors': [
asciichartpy.blue,
asciichartpy.red
],
'height': 10,
'format': '{:6.0f}kB'
}
total_length = len(self.size_diffs)
try:
count = int(args[-1])
except (TypeError, ValueError, IndexError):
count = total_length
if count > total_length:
self.log('Only %i measurements available!' % total_length, lvl=warn)
count = total_length
if count > width:
self.log('Clipping %i values due to terminal width of only '
'%i columns!' % (count - width, width), lvl=warn)
count = width
size_k = [x / 1024.0 for x in islice(
self.size_diffs, len(self.size_diffs) - count, len(self.size_diffs)
)]
if len(args) > 0:
if "-o" in args:
size_k.pop(0)
length = len(size_k)
self.log(
"Memory consumption (%i measurements, "
"%i seconds interval, %3.0f minutes total)" % (
length,
self.interval,
(length * self.interval / 60.0)
)
)
self.log("\n%s" % asciichartpy.plot(size_k, config), nc=True)
def updateChart(exchange, symbol, tf, height):
store = Arctic('localhost')
library = store[exchange.upper()]
startDate = pd.to_datetime('today') - timedelta(days=5)
endDate = startDate + timedelta(days=7)
startDate = startDate.strftime("%Y-%m-%d")
endDate = endDate.strftime("%Y-%m-%d")
readStr = 'trades-' + str(symbol)
item = library.read(readStr, chunk_range=pd.date_range(startDate,
endDate)).copy()
df = item.price.resample(tf).agg({
'open': 'first',
'high': 'max',
'low': 'min',
'close': 'last'
})
df = df.fillna(method='ffill')
chart = plot(df.close.tail(60), {'height': height})
priceStr = str(item.price.iat[-1])
if (item.price.iat[-1] < item.price.iat[-2]):
priceStr = Fore.RED + priceStr
else:
priceStr = Fore.GREEN + priceStr
priceStr = priceStr + Style.RESET_ALL
exchangeStr = exchange
if (exchangeStr == "Bitfinex"):
exchangeStr = Fore.GREEN + exchangeStr
elif (exchangeStr == "Coinbase"):
exchangeStr = Fore.BLUE + exchangeStr
exchangeStr = exchangeStr + Style.RESET_ALL
exchangeStr = exchange
if (exchangeStr == "Bitfinex"):
exchangeStr = Fore.GREEN + exchangeStr
elif (exchangeStr == "Coinbase"):
exchangeStr = Fore.BLUE + exchangeStr
exchangeStr = exchangeStr + Style.RESET_ALL
os.system('clear')
print(f'Exchange: {exchangeStr}')
print(f'Symbol: {symbol}')
print(f'Timeframe: {tf}')
print(f'Price: {priceStr}')
print(f'{chart}')
time.sleep(15)
def print_chart(exchange, symbol, timeframe):
print("\n" + exchange.name + ' ' + symbol + ' ' + timeframe + ' chart:')
# get a list of ohlcv candles
ohlcv = exchange.fetch_ohlcv(symbol, timeframe)
# get the ohlCv (closing price, index == 4)
series = [x[index] for x in ohlcv]
# print the chart
print("\n" + plot(series[-120:], {'height': 20})) # print the chart
last = ohlcv[len(ohlcv) - 1][index] # last closing price
return last
def analyze_file(service, file_id, file_name, dt):
groupby_freq = '10s'
seconds = (dt.index.max() - dt.index.min()).total_seconds()
if seconds > 90 * 60:
groupby_freq = '1 min'
if seconds > 30 * 60:
groupby_freq = '30s'
elif seconds > 30 * 60:
groupby_freq = '10s'
print("Data grouped in %s intervals" % groupby_freq)
print("Speeds (mph):")
speeds_mph = (dt.speed / 1.609).groupby(
pandas.Grouper(freq=groupby_freq)).max().fillna(0)
print(asciichartpy.plot(speeds_mph, {"height": 10}))
print("\n")
print("System Temp (F):")
system_temp = ((dt.system_temp * 9 / 5) + 32).groupby(
pandas.Grouper(freq=groupby_freq)).max().fillna(0)
print(asciichartpy.plot(system_temp, {"height": 10}))
print("\n")
print("CPU Temp (F):")
cpu_temp = ((dt.cpu_temp * 9 / 5) + 32).groupby(
pandas.Grouper(freq=groupby_freq)).max().fillna(0)
print(asciichartpy.plot(cpu_temp, {"height": 10}))
print("\n")
print("Power")
power = dt.power.groupby(pandas.Grouper(freq=groupby_freq)).max().fillna(0)
print(asciichartpy.plot(power, {"height": 10, "max": 2000}))
print("\n")
print("Current")
current = dt.current.groupby(
pandas.Grouper(freq=groupby_freq)).max().fillna(0)
print(asciichartpy.plot(current, {"height": 10}))
print("\n")
print("Tilt")
tilt = dt.tilt.groupby(pandas.Grouper(freq=groupby_freq)).mean().fillna(0)
print(asciichartpy.plot(tilt, {"height": 10}))
print("\n")
print("Roll")
roll = dt.roll.groupby(pandas.Grouper(freq=groupby_freq)).mean().fillna(0)
print(asciichartpy.plot(roll, {"height": 10}))
print("\n")
def __rich_console__(self, console: Console,
options: ConsoleOptions) -> RenderResult:
def _slice(items, max_items):
items = list(items)
items_len = min(len(items), max_items)
return items[-items_len:]
height = (options.height or options.size.height) - 1
graph = asciichartpy.plot(
series=[_slice(s, options.max_width - 10) for s in self.series],
cfg={
"min": 0,
"max": self.max,
"height": height,
"colors": self.colors,
},
)
yield Text("\n").join(self.decoder.decode(graph))
def print_chart(exchange, symbol):
print("\n" + exchange + ' ' + symbol + ' chart:')
# get a list of ohlcv candles
ohlcv = pd.read_csv('market_data/BINANCE_BTC_USDT_SMALL.csv')
close = ohlcv.Close.iloc[:150].values
# get the ohlCv (closing price, index == 4)
# series = [x for x in close]
# print the chart
print("\n" + plot(close[-120:-1], {'height': 10})) # print the chart
try:
last = ohlcv.Close.iloc[-1] # last closing price
except Exception as e:
print(e)
return last
def graph_format(self, reply):
timestamp = reply['chart']['result'][0]['timestamp']
ticket = reply['chart']['result'][0]['meta']
price = reply['chart']['result'][0]['indicators']['quote'][0]['open']
mass = [x for x in price if x is not None]
while len(mass) >= 70:
for x in range(len(mass)):
if x % 3 == 0 and x < len(mass):
del mass[x]
print(ticket.get("symbol"), "timestamp:", ''.join(args.t))
time_tuple1 = time.localtime(timestamp[0])
time_tuple2 = time.localtime(timestamp[-1])
print("START:", (time.strftime("%D %H:%M", time_tuple1)), " ",
"END:", (time.strftime("%D %H:%M", time_tuple2)))
print(asciichartpy.plot(mass, {'height': 10}))
print("-----------------------------------------------")
def print_chart(exchange, symbol, timeframe):
# get a list of ohlcv candles
ohlcv = exchange.fetch_ohlcv(symbol, timeframe)
# get the ohlCv (closing price, index == 4)
series = [x[index] for x in ohlcv]
# print datetime and other values
for x in ohlcv:
print(exchange.iso8601(x[0]), x)
print("\n" + exchange.name + ' ' + symbol + ' ' + timeframe + ' chart:')
# print the chart
print("\n" + asciichartpy.plot(series[-length:],
{'height': height})) # print the chart
last = ohlcv[len(ohlcv) - 1][index] # last closing price
return last
def asciichart(series, cfg=None, maxlines=100):
"""Wraps asciichart.plot() to fix y-axis numbers alignment and warn of too great a height."""
def fix_asciichart(lines):
dotidx = max([line.index(".") for line in lines if "." in line])
lines_ = []
for line in lines:
try:
idx = line.index(".")
lines_.append(" "*(dotidx-idx)+line)
except ValueError:
lines_.append(line)
return "\n".join(lines_)
text = asciichartpy.plot(series, cfg)
lines = text.split("\n")
if len(lines) > maxlines:
raise ValueError(f"Your chart has more than {maxlines} of text; maybe you would like to specify cfg['height']?")
text = fix_asciichart(lines)
return text
def draw_qho(self):
from asciichartpy import plot
path = "test/static/methane_normal.out"
file = cctk.GaussianFile.read_file(path)
mol = file.get_molecule()
mode = mol.vibrational_modes[-1]
for level in range(10):
tp = mode.classical_turning_point(level=level)
print(
f"LEVEL {level} ({mode.energy(level):.2f} kcal.mol, turning point = {tp:.2f} Å)"
)
tp = 5
print(
plot([
mode.quantum_distribution_value(x, level=level)
for x in np.linspace(-1 * tp, tp, 100)
], {"height": 10}))
def handle(self, *args, **options):
refresh_seconds = options['refresh']
width = options['width']
height = options['height']
jctl = JobStatusController(width)
conf = {
'colors': [chart_color_lookup(p.color) for p in jctl.plots],
'height': height,
}
while True:
jctl.tick()
draw = chart.plot(jctl.series(), conf)
status_line = jctl.generate_status()
clear_screen()
print(draw)
sys.stdout.write(status_line)
time.sleep(refresh_seconds)
def report(self,
groundTruth: Union[np.ndarray, pd.core.frame.DataFrame],
predicted: Union[np.ndarray, pd.core.frame.DataFrame],
ascii_chart_config: dict = {}):
_pred = predicted.copy() * 128
_gt = groundTruth.copy() * 128
error = (predicted - groundTruth) * 128
self.log.info('Linear regression evaluation report:')
self.log.info(' |- Max error: {}'.format(np.max(error)))
self.log.info(' |- Min error: {}'.format(np.min(error)))
self.log.info(' |- Average error: {}'.format(np.mean(error)))
self.log.info(' |- Average absolute error: {}'.format(
np.mean(np.abs(error))))
self.log.debug(
' |- Loss value between ground truth and prediction: {}'.format(
error))
#
config = {
'colors': [chart.red, chart.green, chart.blue],
'height': 15,
'max': 128,
'display_width': 100
}
config.update(ascii_chart_config)
#
legend = "+{:=^20}+\n|{:^20}|\n|{:^20}|\n|{:^20}|\n+{:=^20}+" \
.format('Legend', 'Green: Prediction', 'Red: Ground Truth', 'Blue: Error value', '')
#
_display = config['display_width']
#
out_chart = chart.plot(series=[
_gt.tolist()[:_display],
_pred.tolist()[:_display], (_pred - _gt).tolist()[:_display]
],
cfg=config)
log_msg = "\nKernel type: {:=^20}".format(self.model_name) + "\n" + \
"\n" + legend + "\n" + "+===[Performance report on evaluation data]===+" + "\n" + out_chart
self.log.info(log_msg)
def _cnn_stats(self, input_size):
layers = self._get_layer_stats()
_print_tabular = []
_receptive_field = []
for i in range(len(layers)):
layer = layers[i]
if i > 0:
prev_layer = layers[i - 1]
layer.prev_layer = prev_layer
layer.input_size = prev_layer.output_size()
else:
layer.prev_layer = None
layer.input_size = input_size
_print_tabular.append([
i,
type(layer).__name__, layer.kernel_size, layer.stride,
layer.dilation, layer.padding, layer.input_size,
layer.output_size(),
layer.receptive_field()
])
_receptive_field.append(layer.receptive_field())
print(
tabulate(_print_tabular,
headers=("Layer #", "Name", "Kernel Size", "Stride",
"Dilation", "Padding", "Input Size",
"Output Size", "Receptive Field")))
print(
asciichartpy.plot(list(
itertools.chain.from_iterable(
itertools.repeat(x, 5) for x in _receptive_field)),
cfg={"height": 10}))
return layer.output_size()
def plotData(data, bins, params):
large_pixels = [pixel % 16 not in [0, 1, 14, 15] for pixel in range(256)]
print(params)
for slot in range(1, 3 + 1):
d = np.asarray(data['Slot%d' % slot])
p = params['Slot%d' % slot]
if p is None:
d = d[:, large_pixels].flatten()
d = d[d > 0]
else:
d = np.asarray([
ToTtoEnergySimple(d.T[pixel], p[str(pixel)]['a'],
p[str(pixel)]['b'], p[str(pixel)]['c'],
p[str(pixel)]['t']) for pixel in range(256)
])
d = d[large_pixels].flatten()
h, b = np.histogram(d, bins=bins)
# Ascii plot
res = asciichartpy.plot(h / np.max(h) * 30)
print(res)
# Matplotlib
if MATPLOTLIB:
plt.step(b[:-1],
h,
where='post',
color='C%d' % (slot - 1),
label='Slot%d' % slot)
if MATPLOTLIB:
plt.legend()
plt.xlabel('Energy (keV)')
plt.ylabel('Counts')
plt.grid()
plt.show()
def draw_screen(msg_buf, price_buf):
print(chr(27) + "[2H" + chr(27) + "[2J") # CLS
if len(price_buf) > 1:
print(asciichartpy.plot(list(price_buf), {"height": 25}))
for msg in reversed(msg_buf):
print(msg)
temps = np.array([f.temperature() for f in traj.frames])
energies = np.array([f.energy for f in traj.frames][:-1])
rel_energies = energies - np.min(energies)
rel_energies = energies * 627.509
max_width = 100
scale = math.ceil(len(energies) / max_width)
if scale < 1:
scale == 1
height = 16
print(f"TEMPERATURE:\t\t{np.mean(temps):.2f} K (± {np.std(temps):.2f})")
print(
plot(
np.mean(temps[:(len(temps) // scale) * scale].reshape(-1, scale),
axis=1), {"height": height}))
print(
f"ENERGY:\t\t\t{np.mean(energies):.2f} (± {np.std(energies)*627.509:.2f} kcal/mol)"
)
print(
plot(
np.mean(rel_energies[:(len(rel_energies) // scale) * scale].reshape(
-1, scale),
axis=1), {"height": height}))
if args["movie"]:
movie_path = re.sub("chk$", "pdb", args["checkpoint_filename"])
print(f"writing movie to {movie_path}...")
traj.write_movie(movie_path, idxs=args["movie"])
def go():
global CLIARGS, global_vars
site_id = global_vars['site_id']
####CODE GOES BELOW HERE#########
days_ago = CLIARGS['days'] ###How many days ago to look
statistics_period = CLIARGS['period']
hours_ago = days_ago * 24
today = datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)
#start_time = str((datetime.today() - timedelta(hours=hours_ago)).isoformat())
#end_time = str((datetime.today() - timedelta(hours=(hours_ago-statistics_period))).isoformat())
start_time = str((today - timedelta(hours=hours_ago)).isoformat())
end_time = str(
(today - timedelta(hours=(hours_ago - statistics_period))).isoformat())
topology_filter = '{"type":"basenet","nodes":["' + site_id + '"]}'
resp = cgx_session.post.topology(topology_filter)
phy_link_array = []
link_count = 0
print("LINKS at SITE", global_vars['site_name'])
if resp.cgx_status:
topology_list = resp.cgx_content.get("links", None)
for links in topology_list:
if ((links['type'] == 'internet-stub')):
link_count += 1
print(str(link_count) + ") " + str(links['network']))
phy_link_array.append(links)
###path_id in LINKS is path in JSON
if len(phy_link_array) == 1:
global_vars['link'] = phy_link_array[0]
print(
"Only one Physical Link found at site. Implicitly selecting LINK 1 above..."
)
elif len(phy_link_array) > 1:
user_input = 0
while not (0 < user_input <= len(phy_link_array)):
user_input = int(
input("Please Select the Physical link above (1 - " +
str(len(phy_link_array)) + "):"))
global_vars['link'] = phy_link_array[user_input]
else:
print("Error! No Physical Interfaces at site found!")
return False
print("")
global_vars['path_id'] = global_vars['link']['path_id']
path_id = global_vars['path_id']
json_request = '{"start_time":"' + start_time + 'Z","end_time":"' + end_time + 'Z","interval":"5min","view":{"summary":false,"individual":"direction"},"filter":{"site":["' + site_id + '"],"path":["' + path_id + '"]},"metrics":[{"name":"PathCapacity","statistics":["average"],"unit":"Mbps"}]}'
print("Displaying Graphs for Time Period from", start_time, " ---- ",
end_time)
bw_capacity_result = cgx_session.post.metrics_monitor(json_request)
cgx_bw_results = bw_capacity_result.cgx_content.get("metrics")
bw_metrics = {}
bw_metrics['egress'] = []
bw_metrics['ingress'] = []
direction = ""
for directions in cgx_bw_results[0]['series']:
if directions['view']['direction'] == "Ingress":
direction = 'ingress'
if directions['view']['direction'] == "Egress":
direction = 'egress'
for datapoint in directions['data'][0]['datapoints']:
if datapoint['value'] is not None:
bw_metrics[direction].append(datapoint['value'])
ascii_chart_config = {}
ascii_chart_config['height'] = CLIARGS['graphheight'] #Default 15
ascii_chart_config['min'] = 10
hrow = [0] * len(bw_metrics['egress'])
print("")
print("EGRESS BANDWIDTH STATISTICS from", days_ago, "days ago for",
statistics_period, "hour period at site", global_vars['site_name'],
"for interface", global_vars['link']['network'])
print(plot([bw_metrics['egress']], ascii_chart_config))
print(plot(hrow))
print("")
hrow = [0] * len(bw_metrics['ingress'])
print("INGRESS BANDWIDTH STATISTICS from", days_ago, "days ago for",
statistics_period, "hour period at site", global_vars['site_name'],
"for interface", global_vars['link']['network'])
print(plot([bw_metrics['ingress']], ascii_chart_config))
print(plot(hrow))
# -*- coding: utf-8 -*-
# ------------------------------------------------------------------------------
from math import cos
from math import pi
# ------------------------------------------------------------------------------
from asciichartpy import plot
# ------------------------------------------------------------------------------
width = 90
series = [7 * round(cos(i * ((pi * 4) / width)), 2) for i in range(width)]
print(plot(series))
series = [2.0] * width
print(plot(series))
print(plot(series, {'height':5}))
series = [0.0] * width
print(plot(series))
print(plot(series, {'height':5}))
# -*- coding: utf-8 -*- # ------------------------------------------------------------------------------ from math import cos from math import pi # ------------------------------------------------------------------------------ from asciichartpy import plot # ------------------------------------------------------------------------------ width = 90 series = [7 * round(cos(i * ((pi * 4) / width)), 2) for i in range(width)] print(plot(series))
print(f"{output_file.num_imaginaries()} imaginary frequencies")
if output_file.num_imaginaries():
freqs = [f"{f:.1f} cm-1" for f in output_file.imaginaries()]
for f in freqs:
print(f"\t{f}")
print("\n\033[3manalysis:\033[0m")
print(f"{len(output_file.ensemble)} iterations completed")
property_names = [
"scf_iters", "energy", "quasiharmonic_gibbs_free_energy", "rms_force",
"rms_displacement", "rms_gradient"
]
properties = output_file.ensemble[:, property_names]
if len(output_file.ensemble) == 1:
properties = [properties]
df = pd.DataFrame(properties, columns=property_names).fillna(0)
df["rel_energy"] = (df.energy - df.energy.min()) * 627.509469
print("\n\033[1mENERGY (kcal/mol):\033[0m")
print(plot(df["rel_energy"], {"height": 12, "format": " {:8.2f} "}))
print("\n\033[1mRMS GRADIENT:\033[0m")
print(plot(df["rms_gradient"], {"height": 12, "format": " {:8.6f} "}))
print("\n\033[1mRMS FORCE:\033[0m")
print(plot(df["rms_force"], {"height": 12, "format": " {:8.6f} "}))
print("\n\033[1mRMS DISPLACEMENT:\033[0m")
print(plot(df["rms_displacement"], {"height": 12, "format": " {:8.4f} "}))
def populateScreen(bot, open_orders, buy_orders, sell_orders):
df = bot.exchange.getOHLCV(bot.symbol, '5m', 100)
buys_plots = []
sells_plots = []
plot_colors = [asciichartpy.white]
min_price = float(min(df['close'].tolist()))
max_price = float(max(df['close'].tolist()))
for order in buy_orders:
p = [float('nan') for i in range(90)]
p.extend([float(order.price) for i in range(10)])
if min_price > float(order.price):
min_price = float(order.price)
buys_plots.append(p)
plot_colors.append(asciichartpy.green)
for order in sell_orders:
p = [float('nan') for i in range(90)]
p.extend([float(order.price) for i in range(10)])
if max_price < float(order.price):
max_price = float(order.price)
sells_plots.append(p)
plot_colors.append(asciichartpy.red)
plots = [df['close'].tolist()]
if len(buys_plots) > 0:
plots.extend(buys_plots)
if len(sells_plots) > 0:
plots.extend(sells_plots)
max_price = max_price * 1.005
min_price = min_price * 0.995
# print(len(plots), len(plot_colors), len(buys_plots), len(sells_plots))
bot.screen.clear()
bot.screen.refresh()
# curses.endwin()
bot.screen.addstr(
1, 1, bot.symbol +
' price chart (last price: {})'.format(df['close'][len(df) - 1]))
plot_config = {'height': 40, 'min': min_price, 'max': max_price}
price_plot = asciichartpy.plot(df['close'].tolist(), plot_config)
buy_plot = asciichartpy.plot([df['close'].tolist(), *buys_plots],
plot_config)
sell_plot = asciichartpy.plot([df['close'].tolist(), *sells_plots],
plot_config)
k = 3
for line in price_plot.split('\n'):
bot.screen.addstr(k, 0, line, curses.color_pair(1))
k += 1
k = 3
for line in buy_plot.split('\n'):
q = 0
for char in line:
if char != chr(bot.screen.inch(k, q)):
bot.screen.addch(k, q, char, curses.color_pair(2))
q += 1
k += 1
k = 3
for line in sell_plot.split('\n'):
q = 0
for char in line:
if char != chr(bot.screen.inch(k, q)):
bot.screen.addch(k, q, char, curses.color_pair(3))
q += 1
k += 1
bot.screen.refresh()
def main(stdscr):
# Clear screen
stdscr.clear() # clear the screen
stdscr.nodelay(True) # don't wait for input
curses.curs_set(0) # hide the cursor
# this will be hardware dependent and might need to be changed for different systems to find the CPU
# the following is very helpful!
# paste <(cat /sys/class/thermal/thermal_zone*/type) <(cat /sys/class/thermal/thermal_zone*/temp) | column -s $'\t' -t | sed 's/\(.\)..$/.\1°C/'
thermal_zone_number = 1
if len(sys.argv) > 1:
thermal_zone_number = sys.argv[1]
quit_key = 'q'
# in characters
plot_width = 100
plot_height = 30
# TODO: read the terminal size with curses and use that
average_window_length = round(plot_width /
5) # length of running average window
downsample_by = 30 # factor for downsampling
display = deque([], plot_width) # what we'll be displaying
cache = deque() # used in calculating the rolling mean
cum_sum = 0 # used for calculating rolling mean
ds = Downsampler(downsample_by)
# try to get type string
try:
tmp_type = get_type(zone=thermal_zone_number)
except Exception:
tmp_type = "CPU"
while True:
stdscr.erase()
#this_data = get_datapoint()
raw_data = get_datapoint(
zone=thermal_zone_number) # get a new datapoint
while (
this_data := ds.feed(raw_data)
) is None: # feed the downsampler with raw data until it gives us a data point
raw_data = get_datapoint(
zone=thermal_zone_number) # get a new datapoint
# do rolling average computation
cache.append(this_data)
cum_sum += this_data
if len(cache) < average_window_length:
pass
else:
cum_sum -= cache.popleft()
this_avg = cum_sum / float(len(cache))
# draw the plot
to_display = this_avg
#to_display = this_data
stdscr.addstr(
0, 0,
f"{tmp_type} Temperature = {to_display:.2f}°C ===== press {quit_key} to quit ====="
)
display.append(to_display)
stdscr.addstr(1, 0, asciichartpy.plot(display,
{'height': plot_height}))
stdscr.refresh()
ch = stdscr.getch()
if ch == ord(quit_key): # q key ends the program
break
elif ch == ord('r'): # r key does nothing
pass
for i in range(len(layers)):
layer = layers[i]
if i > 0:
prev_layer = layers[i - 1]
layer.prev_layer = prev_layer
layer.input_size = prev_layer.output_size()
else:
layer.prev_layer = None
layer.input_size = input_size
print_tabular.append([
i, layer.name, layer.kernel_size, layer.stride, layer.dilation,
layer.padding(), layer.input_size,
layer.output_size(),
layer.receptive_field()
])
receptive_field.append(layer.receptive_field())
print(
tabulate(print_tabular,
headers=("Layer #", "Name", "Kernel Size", "Stride",
"Dilation", "Padding", "Input Size", "Output Size",
"Receptive Field")))
print(
asciichartpy.plot(list(
itertools.chain.from_iterable(
itertools.repeat(x, 3) for x in receptive_field)),
cfg={"height": 20}))
new_filename = name.rsplit('/',1)[-1] + ".csv"
if os.path.exists(new_filename):
raise ValueError(f"Can't write to {new_filename} -- file already exists!")
with open(new_filename, "w") as timeseries:
timeseries.write(timeseries_text)
x_file_hist, bin_edges = np.histogram(x_dists, bins=100, range=(min_x, max_x))
y_file_hist, bin_edges = np.histogram(y_dists, bins=100, range=(min_y, max_y))
return x_file_hist, y_file_hist, len(x_dists), f"{new_filename}\t{dx:.4f}\t{dy:.4f}\t{kx:.4f}\t{ky:.4f}\n"
# reading is slow, do it in parallel
pool = mp.Pool(processes=1)
for (x_file_hist, y_file_hist, file_count, file_metadata_text) in tqdm.tqdm(pool.imap(read_chk, files), total=len(files)):
x_histogram += x_file_hist
y_histogram += y_file_hist
count += file_count
if file_count > 0:
metadata_text += file_metadata_text
print(f"\nX histogram ({min_x:.2f} to {max_x:.2f}, n={count}):")
print(plot(x_histogram, {"height": 10}))
print(f"\nY histogram ({min_y:.2f} to {max_y:.2f}, n={count}):")
print(plot(y_histogram, {"height": 10}))
with open("metadata.txt", "w") as metadata:
metadata.write(metadata_text)
else:
raise ValueError(f"invalid type {args['type']} - need either ``run`` or ``analyze``!")
dist = mol.get_distance(int(args['atom1']), int(args['atom2']))
dists.append(dist)
timeseries_text += f"{idx}\t{dist:.4f}\n"
if len(dists):
with open(f"{name}.csv", "w") as timeseries:
timeseries.write(timeseries_text)
else:
print(f"skipping {file}")
file_hist, bin_edges = np.histogram(dists, bins=100, range=(min_x, max_x))
return file_hist, len(dists), f"{name}.csv\t{d:.4f}\t{k:.4f}\n"
# reading is slow, do it in parallel
pool = mp.Pool(processes=16)
for (file_hist, file_count, file_metadata_text) in tqdm.tqdm(pool.imap(read_chk, files), total=len(files)):
if file_count:
histogram += file_hist
count += file_count
metadata_text += file_metadata_text
print(f"\nhistogram ({min_x:.2f} to {max_x:.2f}, n={count}):")
print(plot(histogram, {"height": 10}))
with open("metadata.txt", "w") as metadata:
metadata.write(metadata_text)
else:
raise ValueError(f"invalid type {args['type']} - need either ``run`` or ``analyze``!")
for f in traj.frames
]
elif coord[0] == "angle":
Y = [
f.molecule().get_angle(int(coord[1]), int(coord[2]),
int(coord[3])) for f in traj.frames
]
elif coord[0] == "dihedral":
Y = [
f.molecule().get_dihedral(int(coord[1]), int(coord[2]),
int(coord[3]), int(coord[4]))
for f in traj.frames
]
else:
print(f"Unrecognized coordinate type {coord[0]}!")
break
Y = np.asarray(Y)
print(f"\033[3m{' '.join(coord)}\033[0m")
print(
plot(
np.mean(Y[:(len(Y) // scale) * scale].reshape(-1, scale),
axis=1), {"height": 10}))
print("\n")
if args["movie"]:
assert os.path.exists(
args["movie"]), f"can't write to directory {args['movie']}"
traj.write_movie(f"{args['movie']}/{filename}.pdb")
