def test_format_pretty_table():
post1 = Essay(dict(id="1", title="title 1", body="body 1"))
post2 = Essay(dict(id="2", title="title 2", body="body 2"))
posts = Essay.Set([post1, post2])
posts.should.be.a(ModelSet)
posts.format_pretty_table().should.equal(
format_pretty_table(
[["1", "title 1", "body 1"], ["2", "title 2", "body 2"]],
["id", "title", "body"],
)
)
posts.format_pretty_table(["title"]).should.equal(
format_pretty_table([["title 1"], ["title 2"]], ["title"])
)
when_called = posts.format_pretty_table.when.called_with(["inexistent"])
when_called.should.have.raised(
ValueError,
"the following columns are not available for <class 'tests.unit.test_set.Essay'>: {'inexistent'}",
)
async def ingame(cmd, message, args):
games = {}
online_count = 0
playing_count = 0
total_count = 0
for member in message.guild.members:
total_count += 1
status = str(member.status)
if status != 'offline':
online_count += 1
if not member.bot:
if member.game:
game_name = str(member.game)
repl_name = game_name.replace(' ', '')
if repl_name != '':
playing_count += 1
if game_name not in games:
games.update({game_name: 1})
else:
curr_count = games[game_name]
new_count = curr_count + 1
games.update({game_name: new_count})
embed = discord.Embed(color=0x1ABC9C)
sorted_games = sorted(games.items(), key=operator.itemgetter(1))
n = 0
out_table_list = []
game_count = len(sorted_games)
for key, value in reversed(sorted_games):
if n < 5:
n += 1
if len(key) > 32:
key = key[:32] + '...'
out_table_list.append([
str(n),
key.title(), value,
str(((value / playing_count) * 10000) // 100).split('.')[0] +
'%'
])
out = format_pretty_table(out_table_list)
general_stats_list = [['Online', online_count], ['In-Game', playing_count],
['Unique Games', game_count]]
general_stats_out = format_pretty_table(general_stats_list)
embed.add_field(name='👾 Current Gaming Statistics on ' +
message.guild.name,
value='```haskell\n' + general_stats_out + '\n```',
inline=False)
embed.add_field(name='🎮 By Game...',
value='```haskell\n' + out + '\n```',
inline=False)
await message.channel.send(None, embed=embed)
def WPRun(self): count = 0 with Spinner(label="Enumeration") as spinner: for i in range(15): sleep(0.1) spinner.step() print "" self.WPJson() self.WPJson2() column_user = ["ID","Username","Login"] print format_pretty_table(self.CheckUser(self.users),column_user)
def format_pretty_table(self, columns: Iterable[str] = None):
"""returns a string with a pretty table ready to be printed on a terminal.
powered by :py:func:`humanfriendly.tables.format_pretty_table`
"""
columns, rows = self.get_table_columns_and_rows(columns)
return format_pretty_table(rows, columns)
def _display_thanks(self):
if self.give_thanks_to:
cprint('You depend on {} who would {}'.format(
colored('{} authors'.format(len(self.give_thanks_to)), 'cyan'),
colored('enjoy donations!', 'green'),
),
attrs=['bold'])
colorized_data = [
ProjectData(
name=colored(pd.name, 'cyan'),
funding_link=colored(pd.funding_link, 'green'),
authors=colored(pd.authors, 'yellow'),
) for pd in self.give_thanks_to.values()
]
print(
format_pretty_table(
data=colorized_data,
column_names=['Project', 'Where to thank', 'Authors'],
horizontal_bar=' ',
vertical_bar=' ',
))
cprint(''.join([
"If you see projects with ",
colored("MISSING FUNDING INFORMATION ",
"red"), "then why not submit a pull request ",
"the project repository asking the author to ",
colored("ADD A 'FUNDING' PROJECT_URL ",
"yellow"), "to the projects setup.py"
]),
attrs=['bold'])
def run(self):
while True:
login = False
table = ['Username', 'Passowrd']
passwd = self.queue.get()
sys.stdout.write("[ * ] ")
sys.stdout.write("%s\r\r" % passwd)
sys.stdout.flush()
post = """<methodCall><methodName>wp.getUsersBlogs</methodName>
<params><param><value><string>%s</string></value></param><param>
<value><string>%s</string></value></param></params></methodCall>""" % (
self.user, passwd)
resp = self.request.send(url=self.target, method="POST", data=post)
if search(
decode('<name>isAdmin</name><value><boolean>0</boolean>'),
resp.content):
login = True
elif search(
decode('<name>isAdmin</name><value><boolean>1</boolean>'),
resp.content):
login = True
if login is True:
plus('Valid Credentials: ')
normal('')
print(format_pretty_table([[self.user, passwd]], table))
self.queue.task_done()
self.queue.join()
def show_output():
count = 0
header = ["MAC", "Vendor", "Time", "Sig", "SSID"]
current_output = []
nice_ssids = ""
for i in range(0,17):
current_output.append([])
for i in range(0, len(observed_clients)):
if count < 17:
nice_ssids = ""
for s in observed_clients[i].ssid:
if s is not "" and s not in nice_ssids:
nice_ssids = nice_ssids + s + " "
nice_ssids = nice_ssids[:30]
nice_time = str(observed_clients[i].last_seen.hour) + ":" + str(observed_clients[i].last_seen.minute) + ":" + str(observed_clients[i].last_seen.second)
if observed_clients[i].host == True:
nice_time = colored(nice_time, 'red')
nice_ssids = colored(nice_ssids, 'red')
current_output[i] = ([ colored(str(observed_clients[i].mac[9:]), 'red') , colored(observed_clients[i].vendor, 'red'), nice_time, colored(str(observed_clients[i].strength), 'red'), nice_ssids])
else:
current_output[i] = ([ str(observed_clients[i].mac[9:]) , observed_clients[i].vendor, nice_time,str(observed_clients[i].strength), nice_ssids])
count += 1
os.system('clear')
print (format_pretty_table( current_output, header))
print "Clients:", unique_clients," Hosts:", unique_hosts
sys.stdout.softspace=0
def find_package_roles(self, requirements_file):
with open(requirements_file, 'r') as reqs:
print("Scanning your requirements file...")
for req in requirements.parse(reqs):
self.update_give_thanks(req.name)
if req.name in self.local_installs:
for package in self.local_installs[req.name].requires():
self.update_give_thanks(package.key)
if self.give_thanks_to:
print("Found the following contributors to support:")
table_data = []
for contributor in self.give_thanks_to:
table_data.append(
[
colored(contributor, 'blue'),
colored(self.give_thanks_to[contributor]['url'], 'green'),
colored(", ".join(self.give_thanks_to[contributor]['packages']), 'red'),
]
)
print(format_pretty_table(
data=table_data,
column_names=['Author', 'Where to thank', 'Packages'],
horizontal_bar=' ',
vertical_bar=' ',
))
def preload(self):
# sort by priority
self._preload_funcs.sort(key=lambda f: f[0])
logger.debug(
f"{len(self._preload_funcs)} preload functions registered")
if logger.getEffectiveLevel() <= logging.DEBUG:
# dump all the preload functions
prev_priority = -1
table = []
for priority, func in self.preload_funcs:
if priority != prev_priority:
prev_priority = priority
prefix_str = int(priority)
else:
prefix_str = " "
func_name = func.__name__.strip("_")
table.append([prefix_str, func_name])
print(format_pretty_table(table, ["Priority", "Function"]))
logger.info("start preloading")
for _, func in self.preload_funcs:
try:
func()
except UnsupportedDatasetError:
# shunt
raise
except Exception as e:
func_name = func.__name__.strip("_")
raise PreloadError(f'failed at "{func_name}": {str(e)}')
def render_output(self, context):
if 'json' in context:
print context['json']
elif 'table' in context:
print "\n", context['header']
table_params = {'data': context['table']}
print format_pretty_table(**table_params), "\n"
elif 'robust_table' in context:
print "\n", context['header']
table_params = {'data': context['robust_table'],
'column_names': ['code', '']}
print format_robust_table(**table_params), "\n"
elif 'header' in context:
self.render_message(context['header'])
else:
raise YomError('Not enough parameters for output formatting')
def report_job_completed(self, run_ids):
self._ui.output(
"\n\n" + format_pretty_table(self._generate_all_output(run_ids), [
'Benchmark', 'VM', 'Suite', 'Extra', 'Core', 'Size', 'Var',
'#Samples', 'Mean (ms)'
],
vertical_bar=' '))
def draw_rpn_build_table(rpn_stages):
print("R P N S T A G E S")
data = [["\\n" if s.lexeme == "\n" else s.lexeme, s.stack, s.rpn]
for s in rpn_stages]
print(
tbls.format_pretty_table(data, column_names=["Lexeme", "Stack",
"RPN"]))
async def wfacolytes(cmd: SigmaCommand, message: discord.Message, args: list):
try:
api_url = 'https://api.tenno.tools/worldstate/pc'
async with aiohttp.ClientSession() as session:
async with session.get(api_url) as tools_session:
tool_data = await tools_session.read()
world_data = json.loads(tool_data)
except aiohttp.ClientPayloadError:
world_data = {}
acolytes = world_data.get('acolytes')
if acolytes:
acolytes = acolytes.get('data')
else:
acolytes = []
if not acolytes:
response = discord.Embed(color=0x990000, title='No data on the acolytes.')
else:
data_list = []
headers = ['Name', 'Health', 'Location']
for acolyte in acolytes:
name = acolyte.get('name')
health = f"{round(acolyte.get('health') * 100, 2)}%"
if acolyte.get('discovered'):
location = acolyte.get('location')
else:
location = 'Unknown'
entry = [name, health, location]
data_list.append(entry)
data_table = format_pretty_table(data_list, headers)
response = discord.Embed(color=0xcc0000)
response.set_author(name='Warframe Acolyte Data', icon_url=stalker_icon)
response.description = f'```hs\n{data_table}\n```'
await message.channel.send(embed=response)
async def servers(cmd, message, args):
if message.author.id in permitted_id:
serv_lst = []
column_lst = ['Server Name', 'Server ID', 'Members']
for server in cmd.bot.servers:
temp_lst = []
n = len(server.members)
temp_lst.append(str(server))
temp_lst.append(str(server.id))
temp_lst.append(str(n))
serv_lst.append(temp_lst)
server_list = format_pretty_table(serv_lst, column_lst)
out_text = 'List of servers:\n```'
out_text += server_list
if len(out_text) > 1950:
out_text = out_text[:1950]
out_text += '...'
out_text += '\n```'
await cmd.bot.send_message(message.channel, out_text)
else:
error_msg = await cmd.bot.send_message(message.channel,
'Insufficient permissions.')
await asyncio.sleep(5)
await cmd.bot.delete_message(error_msg)
await cmd.bot.delete_message(message)
async def wfacolytes(_cmd, pld):
"""
:param _cmd: The command object referenced in the command.
:type _cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
acolytes = await WorldState().acolytes
if acolytes:
data_list = []
headers = ['Name', 'Health', 'Location']
for acolyte in acolytes:
name = acolyte.get('name')
health = f"{round(acolyte.get('health') * 100, 2)}%"
if acolyte.get('discovered'):
location = acolyte.get('location')
else:
location = 'Unknown'
entry = [name, health, location]
data_list.append(entry)
data_table = format_pretty_table(data_list, headers)
response = discord.Embed(color=0xcc0000)
response.set_author(name='Warframe Acolytes Data', icon_url=stalker_icon)
response.description = f'```hs\n{data_table}\n```'
else:
response = error('No data on the Acolytes.')
await pld.msg.channel.send(embed=response)
def print_formatted_table(delimiter):
"""Read tabular data from standard input and print a table."""
data = []
for line in sys.stdin:
line = line.rstrip()
data.append(line.split(delimiter))
output(format_pretty_table(data))
def Info(self, smb):
print('[+] Showing folders..')
names = []
column = ['Name', 'Type', 'Comments']
shares = smb.listShares()
for share in shares:
names.append([share.name, share.type, share.comments])
print(format_pretty_table(names, column))
def list_builds(version=None,
product="houdini",
platform="linux",
only_production=False):
"""Display a table of builds available to download.
Dates which care colored green indicate they are today's build.
:param version: The major.minor version to download.
:type version: str
:param product: The name of the product to download.
:type product: str
:param platform: The platform to download for.
:type platform: str
:param only_production: Only consider production builds.
:type only_production: bool
:return:
"""
service = _Service()
# Get a list of builds which match the criteria.
releases_list = service.get_available_builds(
product,
version=version,
platform=platform,
only_production=only_production)
headers = ["Build", "Date", "Type"]
# A filtered list of builds.
rows = []
today = datetime.datetime.now().date()
# Filter the builds based on additional settings.
for release in releases_list:
release_type, release_color = _RELEASE_TYPE_MAP[release["release"]]
build_date = datetime.datetime.strptime(release["date"],
"%Y/%m/%d").date()
if build_date == today:
build_date = colored(build_date, "green")
row = [
colored(
"{}.{}".format(release["version"], release["build"]),
_STATUS_MAP[release["status"]],
),
build_date,
colored(release_type, release_color),
]
rows.append(row)
cprint(format_pretty_table(rows, headers))
def run(self):
info('Enumerating users...')
users = []
users = self.wpjson()
users += self.wpjson2()
users += self.wpfeed()
users += self.wpauthor()
text_table = ['ID', 'Username', 'Login']
print(format_pretty_table(self.r_user(users), text_table))
def test_format_pretty_table_without_explicit_visible_attributes():
chuck = Person(
{"age": 42, "name": "Chuck Norris", "email": "*****@*****.**"}
)
chuck.get_table_columns().should.equal(["name", "age"])
chuck.get_table_rows().should.equal([["Chuck Norris", 42]])
chuck.format_pretty_table().should.equal(
format_pretty_table([["Chuck Norris", 42]], ["name", "age"])
)
def render(self):
data = []
column_names = ('Name', 'Type', 'Default', 'Doc Text')
for field in field_iter(self.resource):
data.append([
field.name,
field.__class__.__name__,
'' if field is not NOT_PROVIDED else str(field.default),
field.doc_text
])
self.print(tables.format_pretty_table(data, column_names))
def handle(self, *args, **options):
"""Query all the entries from the catalog model."""
if args:
raise CommandError("infocatalog takes no arguments")
column_names = ['Catalog Name']
# [self.stdout.write(cat, ending='') for cat in Catalog.objects.all()]
catalog = [cat.name for cat in Catalog.objects.all()]
self.stdout.write(format_pretty_table([
catalog,
], column_names))
def test_pretty_tables(self):
"""Test :func:`humanfriendly.tables.format_pretty_table()`."""
# The simplest case possible :-).
data = [['Just one column']]
assert format_pretty_table(data) == dedent("""
-------------------
| Just one column |
-------------------
""").strip()
# A bit more complex: two rows, three columns, varying widths.
data = [['One', 'Two', 'Three'], ['1', '2', '3']]
assert format_pretty_table(data) == dedent("""
---------------------
| One | Two | Three |
| 1 | 2 | 3 |
---------------------
""").strip()
# A table including column names.
column_names = ['One', 'Two', 'Three']
data = [['1', '2', '3'], ['a', 'b', 'c']]
assert ansi_strip(format_pretty_table(data,
column_names)) == dedent("""
---------------------
| One | Two | Three |
---------------------
| 1 | 2 | 3 |
| a | b | c |
---------------------
""").strip()
# A table that contains a column with only numeric data (will be right aligned).
column_names = ['Just a label', 'Important numbers']
data = [['Row one', '15'], ['Row two', '300']]
assert ansi_strip(format_pretty_table(data,
column_names)) == dedent("""
------------------------------------
| Just a label | Important numbers |
------------------------------------
| Row one | 15 |
| Row two | 300 |
------------------------------------
""").strip()
def test_pretty_tables(self):
"""Test :func:`humanfriendly.tables.format_pretty_table()`."""
# The simplest case possible :-).
data = [['Just one column']]
assert format_pretty_table(data) == dedent("""
-------------------
| Just one column |
-------------------
""").strip()
# A bit more complex: two rows, three columns, varying widths.
data = [['One', 'Two', 'Three'], ['1', '2', '3']]
assert format_pretty_table(data) == dedent("""
---------------------
| One | Two | Three |
| 1 | 2 | 3 |
---------------------
""").strip()
# A table including column names.
column_names = ['One', 'Two', 'Three']
data = [['1', '2', '3'], ['a', 'b', 'c']]
assert ansi_strip(format_pretty_table(data, column_names)) == dedent("""
---------------------
| One | Two | Three |
---------------------
| 1 | 2 | 3 |
| a | b | c |
---------------------
""").strip()
# A table that contains a column with only numeric data (will be right aligned).
column_names = ['Just a label', 'Important numbers']
data = [['Row one', '15'], ['Row two', '300']]
assert ansi_strip(format_pretty_table(data, column_names)) == dedent("""
------------------------------------
| Just a label | Important numbers |
------------------------------------
| Row one | 15 |
| Row two | 300 |
------------------------------------
""").strip()
def get(forced, only_one):
'''attiva il programma'''
if forced:
click.echo('\nAggiorno il database\n')
else:
click.echo('\nAggiorno il database se necessario\n')
try:
update_db(forced)
stocks = session.query(Stock).all()
bonds = session.query(Bond).all()
notification_s = check_thresholds(stocks)
notification_b = check_thresholds(bonds)
if notification_s is not None:
table = stock_table(stocks)
pretty_s = format_pretty_table(table[1:], column_names=table[0])
text_s = '{}\n{}\n\n'.format(notification_s.format('azione'),
pretty_s)
else:
text_s = '\nATTENZIONE nessuna azione inserita nel database'
if notification_b is not None:
table = bond_table(bonds)
pretty_b = format_pretty_table(table[1:], column_names=table[0])
text_b = '{}\n{}\n\n'.format(notification_b.format('obbligazione'),
pretty_b)
else:
text_b = '\nATTENZIONE nessuna obbligazione inserita nel database'
if only_one == 'stock':
click.echo(text_s)
elif only_one == 'bond':
click.echo(text_b)
else:
click.echo(''.join([text_s, text_b]))
except SystemExit:
click.echo('\nATTENZIONE nessuna connessione internet')
def main(argv):
if argv == '-h' or argv == '--help':
print(text.Text("ady", color='#0099ff', shadow=True, skew=5))
print("ady -- Bakı -> Sumqayıt -> Bakı hərəkət cədvəli")
print("ady ['-b', '--baku', '--bakı'] -- bakı üçün hərəkət cədvəli")
print(
"ady ['-s', '--sum', '--sumgait', '--sumqayıt'] -- sumqayıt üçün hərəkət cədvəli"
)
print(
"ady ['-a', '--all', '--ha', '--hamısı'] -- hər iki hərəkət cədvəli"
)
else:
getTable()
if argv == "-b" or argv == "--baku" or argv == "--bakı":
print(format_pretty_table(baku_table, baku_header))
sys.exit()
elif argv == "-s" or argv == "--sum" or argv == "--sumgait" or argv == "--sumqayıt":
print(format_pretty_table(sum_table, sum_header))
sys.exit()
elif argv == "-a" or argv == "--all" or argv == "--ha" or argv == "--hamısı":
print(format_pretty_table(baku_table, baku_header))
print(format_pretty_table(sum_table, sum_header))
sys.exit()
def render(self):
mapping = self.mapping
self.title("{}.{}".format(mapping.__module__, mapping.__name__))
self.print('')
self.print("From:", resource_reference(mapping.from_obj))
self.print("To: ", resource_reference(mapping.to_obj))
self.print('')
# Build mapping summary
data = []
column_names = ('From', 'Action', 'To', 'Options')
for from_fields, action, to_fields, to_list, bind, skip_if_none in mapping._mapping_rules:
# Dereference
from_fields = from_fields or ['*Assigned*']
to_fields = to_fields or list()
row_count = max(len(from_fields), len(to_fields))
# Normalise
if len(from_fields) < row_count:
from_fields += [
'' for _ in range(row_count - len(from_fields))
]
if len(to_fields) < row_count:
to_fields += ['' for _ in range(row_count - len(to_fields))]
if action:
if not isinstance(action, six.string_types):
action = str(action)
else:
action = '-->'
options = []
if bind:
options.append('bound')
if skip_if_none:
options.append('skip if None')
options = ', '.join(options)
for idx in range(row_count):
from_field = from_fields[idx]
to_field = to_fields[idx]
if to_list:
to_field = '[{}]'.format(to_field)
if idx == 0:
data.append([from_field, action, to_field, options])
else:
data.append([from_field, '+->', to_field, options])
self.print(tables.format_pretty_table(data, column_names))
def render(self):
mapping = self.mapping
self.title("{}.{}".format(mapping.__module__, mapping.__name__))
self.print('')
self.print("From:", resource_reference(mapping.from_obj))
self.print("To: ", resource_reference(mapping.to_obj))
self.print('')
# Build mapping summary
data = []
column_names = ('From', 'Action', 'To', 'Options')
for from_fields, action, to_fields, to_list, bind, skip_if_none in mapping._mapping_rules:
# Dereference
from_fields = from_fields or ['*Assigned*']
to_fields = to_fields or []
from_fields_len = len(from_fields)
to_fields_len = len(to_fields)
row_count = max(from_fields_len, to_fields_len)
# Normalise
if len(from_fields) < row_count:
from_fields += ['' for _ in range(row_count - from_fields_len)]
if len(to_fields) < row_count:
to_fields += ['' for _ in range(row_count - to_fields_len)]
if action:
if not isinstance(action, six.string_types):
action = str(action)
else:
action = '-->'
options = []
if bind:
options.append('bound')
if skip_if_none:
options.append('skip if None')
options = ', '.join(options)
for idx in range(row_count):
from_field = from_fields[idx]
to_field = to_fields[idx]
if to_list:
to_field = '[{}]'.format(to_field)
if idx == 0:
data.append([from_field, action, to_field, options])
else:
data.append([from_field, '+->', to_field, options])
self.print(tables.format_pretty_table(data, column_names))
def showFolder(self, smb, path):
print('[+] Show %s Files...' % (path))
names = []
column = ['Filename', 'ReadOnly']
try:
dir_ = smb.listPath(path, '/')
except Exception as e:
print(
'[!] Failed to list \ on %s: Unable to connect to shared device'
% path)
exit(0)
for file in dir_:
names.append([file.filename, file.isReadOnly])
print(format_pretty_table(names, column))
exit(0)
def test_format_pretty_table():
post1 = BlogPost(dict(id=1, title="title 1", body="body 1"))
post2 = BlogPost(dict(id=2, title="title 2", body="body 2"))
posts = BlogPost.List([post1, post2])
posts.should.be.a(ModelList)
posts.format_pretty_table().should.equal(
format_pretty_table(
[[1, "title 1", "body 1"], [2, "title 2", "body 2"]],
["id", "title", "body"],
))
posts.format_pretty_table(["title"]).should.equal(
format_pretty_table([["title 1"], ["title 2"]], ["title"]))
when_called = posts.format_pretty_table.when.called_with(["inexistent"])
when_called.should.have.raised(
ValueError,
"the following columns are not available for <class 'tests.unit.test_list.BlogPost'>: {'inexistent'}",
)
def test_format_pretty_table():
chuck = User({
"id": 1,
"username": "******",
"email": "*****@*****.**"
})
chuck.get_table_columns().should.equal(["id", "username", "email"])
chuck.get_table_rows().should.equal(
[[1, "chucknorris", "*****@*****.**"]])
chuck.format_pretty_table().should.equal(
format_pretty_table(
[[1, "chucknorris", "*****@*****.**"]],
["id", "username", "email"],
))
def testFile(self,file):
res = []
code = readfile(file)
res += self.csrf(code)
res += self.ope(code)
res += self.pce(code)
res += self.com(code)
res += self.auth(code)
res += self.php(code)
res += self.fin(code)
res += self.fid(code)
res += self.sql(code)
res += self.xss(code)
if res != []:
print(format_pretty_table(res,self.table))
else: plus('Not found vulnerabilities')
def draw_lexeme_table(tokens):
print("L E X E M S")
data = []
for t in tokens:
row = [t.row_num, t.tag]
if hasattr(t, "payload"):
str_value = "\\n" if t.payload == "\n" else t.payload
row.append(str_value)
elif t.tag in cmn.SYMBOLS.values():
row.append(get_string_repr(cmn.SYMBOLS, t.tag))
elif t.tag in cmn.WORDS.values():
row.append(get_string_repr(cmn.WORDS, t.tag))
row.append(t.index) if hasattr(t, "index") else row.append("")
data.append(row)
print(
tbls.format_pretty_table(
data, column_names=["Row", "Tag", "Payload", "Index"]))
def _generate_output(self, colored_output=True):
def _uncolored(text, *args, **kwargs):
return text
colored = termcolor.colored if colored_output else _uncolored
lines = []
lines.append(
colored('You depend on {} who would {}'.format(
colored('{} authors'.format(len(self.give_thanks_to)), 'cyan'),
colored('enjoy donations!', 'green'),
),
attrs=['bold']
)
)
colorized_data = [
ProjectData(
name=colored(pd.name, 'cyan'),
funding_link=colored(pd.funding_link, 'green'),
authors=colored(pd.authors, 'yellow'),
)
for pd in self.give_thanks_to.values()
]
lines.append(format_pretty_table(
data=colorized_data,
column_names=['Project', 'Where to thank', 'Authors'],
horizontal_bar=' ',
vertical_bar=' ',
))
lines.append(
''.join([
"See projects without ",
colored("FUNDING INFORMATION", "red"),
"? Why not submit a pull request to ",
"the project asking the author to add a ",
colored("'FUNDING' PROJECT_URL ", "yellow"),
"to the project's setup.py. ",
"https://packaging.python.org/guides/",
"distributing-packages-using-setuptools/#project-urls\n"
]),
)
return '\n'.join(lines)
async def rolepopulation(cmd, message, args):
if args:
rl_qry = ' '.join(args)
role_search = discord.utils.find(lambda x: x.name.lower() == rl_qry.lower(), message.guild.roles)
if not role_search:
response = discord.Embed(color=0x696969, title=f'🔍 {rl_qry} not found.')
await message.channel.send(embed=response)
return
counter = 0
for member in message.guild.members:
member_role_search = discord.utils.find(lambda x: x.id == role_search.id, member.roles)
if member_role_search:
counter += 1
response = discord.Embed(color=role_search.color)
response.set_author(name=message.guild.name, icon_url=message.guild.icon_url)
response.add_field(name=f'{role_search.name} Population', value=f'```[y\n{counter}\n```')
await message.channel.send(embed=response)
else:
role_dict = {}
for role in message.guild.roles:
if role.name == '@everyone': continue
role_key = role.name
role_count = 0
for member in message.guild.members:
member_role_search = discord.utils.find(lambda x: x.id == role.id, member.roles)
if member_role_search:
role_count += 1
role_dict.update({role_key: role_count})
sorted_roles = sorted(role_dict.items(), key=operator.itemgetter(1), reverse=True)
output = []
for srole in sorted_roles[:20]:
output.append([srole[0], srole[1], f'{str(percentify(srole[1], len(message.guild.members)))}%'])
out_text = format_pretty_table(output)
response = discord.Embed(color=0x0099FF)
response.set_author(name=message.guild.name, icon_url=message.guild.icon_url)
response.add_field(name='Statistics', value=f'```py\nShowing {len(output)} roles out of {len(message.guild.roles)}\n```', inline=False)
response.add_field(name=f'Role Population', value=f'```haskell\n{out_text}\n```', inline=False)
await message.channel.send(embed=response)
def show():
'''mostra le azioni e obbligazioni inserite'''
table_s, table_b = show_assets()
pretty_table_s = format_pretty_table(table_s[1:], table_s[0])
pretty_table_b = format_pretty_table(table_b[1:], table_b[0])
click.echo_via_pager('{}\n{}'.format(pretty_table_s, pretty_table_b))
