def list(self):
"""List the Drbd volumes and statuses"""
# Set permissions as having been checked, as listing VMs
# does not require permissions
self._get_registered_object('auth').set_permission_asserted()
# Create table and add headers
table = Texttable()
table.set_deco(Texttable.HEADER | Texttable.VLINES)
table.header(('Name', 'Type', 'Location', 'Nodes', 'Shared', 'Free Space', 'ID'))
# Set column alignment and widths
table.set_cols_width((15, 5, 30, 70, 6, 15, 50))
table.set_cols_align(('l', 'l', 'l', 'l', 'l', 'l', 'l'))
for storage_backend in self.get_all():
table.add_row((
storage_backend.name,
storage_backend.storage_type,
storage_backend.get_location(),
', '.join(storage_backend.nodes),
str(storage_backend.shared),
SizeConverter(storage_backend.get_free_space()).to_string(),
storage_backend.id_
))
return table.draw()
def get_aggregation_summary_text(self, matches):
text = ''
if 'aggregation' in self.rule and 'summary_table_fields' in self.rule:
summary_table_fields = self.rule['summary_table_fields']
if not isinstance(summary_table_fields, list):
summary_table_fields = [summary_table_fields]
# Include a count aggregation so that we can see at a glance how many of each aggregation_key were encountered
summary_table_fields_with_count = summary_table_fields + ['count']
text += "Aggregation resulted in the following data for summary_table_fields ==> {0}:\n\n".format(summary_table_fields_with_count)
text_table = Texttable()
text_table.header(summary_table_fields_with_count)
match_aggregation = {}
# Maintain an aggregate count for each unique key encountered in the aggregation period
for match in matches:
key_tuple = tuple([unicode(lookup_es_key(match, key)) for key in summary_table_fields])
if key_tuple not in match_aggregation:
match_aggregation[key_tuple] = 1
else:
match_aggregation[key_tuple] = match_aggregation[key_tuple] + 1
for keys, count in match_aggregation.iteritems():
text_table.add_row([key for key in keys] + [count])
text += text_table.draw() + '\n\n'
return unicode(text)
def do_delete(self, args):
try:
#add arguments
doParser = self.arg_delete()
doArgs = doParser.parse_args(shlex.split(args))
#if the help command is called, parse_args returns None object
if not doArgs:
return 2
#call UForge API
printer.out("Searching bundle with id ["+doArgs.id+"] ...")
myBundle = self.api.Users(self.login).Mysoftware(doArgs.id).Get()
if myBundle is None or type(myBundle) is not MySoftware:
printer.out("Bundle not found", printer.WARNING)
else:
table = Texttable(800)
table.set_cols_dtype(["t","t","t", "t","t", "t"])
table.header(["Id", "Name", "Version", "Description", "Size", "Imported"])
table.add_row([myBundle.dbId, myBundle.name, myBundle.version, myBundle.description, size(myBundle.size), "X" if myBundle.imported else ""])
print table.draw() + "\n"
if generics_utils.query_yes_no("Do you really want to delete bundle with id "+str(myBundle.dbId)):
self.api.Users(self.login).Mysoftware(myBundle.dbId).Delete()
printer.out("Bundle deleted", printer.OK)
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: "+str(e), printer.ERROR)
self.help_delete()
except Exception as e:
return handle_uforge_exception(e)
def top(db):
count_query = '''
SELECT count(*)
FROM commands
WHERE
timestamp > ?
'''
percentage = 100 / float(execute_scalar(db, count_query, TIMESTAMP))
query = '''
SELECT count(*) AS counts, command
FROM commands
WHERE timestamp > ?
GROUP BY command
ORDER BY counts DESC
LIMIT 20
'''
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_cols_align(('r', 'r', 'l'))
table.header(('count', '%', 'command'))
for row in db.execute(query, (TIMESTAMP,)):
table.add_row((row[0], int(row[0]) * percentage, row[1]))
print table.draw()
def __repr__(self):
t = Texttable()
for rowId in range(0,self.size[0]):
rowDetails = []
for cellId in range(0,self.size[1]):
cell = self.cellAtLocation(cellId,rowId)
color = {
"free": bcolors.WHITE,
"mine": bcolors.PURPLE,
"theirs": bcolors.RED
}[cell.getState()]
rowDetails.append(
get_color_string(color, cell)
)
t.add_row(rowDetails)
return "\n".join([
t.draw(),
self.board,
self.state
])
def list(self):
"""List the Drbd volumes and statuses"""
# Create table and add headers
table = Texttable()
table.set_deco(Texttable.HEADER | Texttable.VLINES)
table.header(('Volume Name', 'VM', 'Minor', 'Port', 'Role', 'Connection State',
'Disk State', 'Sync Status'))
# Set column alignment and widths
table.set_cols_width((30, 20, 5, 5, 20, 20, 20, 13))
table.set_cols_align(('l', 'l', 'c', 'c', 'l', 'c', 'l', 'c'))
# Iterate over Drbd objects, adding to the table
for drbd_object in self.get_all_drbd_hard_drive_object(True):
table.add_row((drbd_object.resource_name,
drbd_object.vm_object.get_name(),
drbd_object.drbd_minor,
drbd_object.drbd_port,
'Local: %s, Remote: %s' % (drbd_object._drbdGetRole()[0].name,
drbd_object._drbdGetRole()[1].name),
drbd_object._drbdGetConnectionState().name,
'Local: %s, Remote: %s' % (drbd_object._drbdGetDiskState()[0].name,
drbd_object._drbdGetDiskState()[1].name),
'In Sync' if drbd_object._isInSync() else 'Out of Sync'))
return table.draw()
def do_list(self, args):
try:
#call UForge API
printer.out("Getting scans for ["+self.login+"] ...")
myScannedInstances = self.api.Users(self.login).Scannedinstances.Get(None, Includescans="true")
if myScannedInstances is None or not hasattr(myScannedInstances, 'get_scannedInstance'):
printer.out("No scans available")
return
else:
table = Texttable(800)
table.set_cols_dtype(["t","t","t","t"])
table.header(["Id", "Name", "Status", "Distribution"])
myScannedInstances = generics_utils.oder_list_object_by(myScannedInstances.get_scannedInstance(), "name")
for myScannedInstance in myScannedInstances:
table.add_row([myScannedInstance.dbId, myScannedInstance.name, "", myScannedInstance.distribution.name + " "+ myScannedInstance.distribution.version + " " + myScannedInstance.distribution.arch])
scans = generics_utils.oder_list_object_by(myScannedInstance.get_scans().get_scan(), "name")
for scan in scans:
if (scan.status.complete and not scan.status.error and not scan.status.cancelled):
status = "Done"
elif(not scan.status.complete and not scan.status.error and not scan.status.cancelled):
status = str(scan.status.percentage)+"%"
else:
status = "Error"
table.add_row([scan.dbId, "\t"+scan.name, status, "" ])
print table.draw() + "\n"
printer.out("Found "+str(len(myScannedInstances))+" scans")
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: "+str(e), printer.ERROR)
self.help_list()
except Exception as e:
return generics_utils.handle_uforge_exception(e)
def do_search(self, args):
try:
#add arguments
doParser = self.arg_search()
doArgs = doParser.parse_args(shlex.split(args))
#if the help command is called, parse_args returns None object
if not doArgs:
return 2
#call UForge API
printer.out("Search package '"+doArgs.pkg+"' ...")
distribution = self.api.Distributions(doArgs.id).Get()
printer.out("for OS '"+distribution.name+"', version "+distribution.version)
pkgs = self.api.Distributions(distribution.dbId).Pkgs.Getall(Query="name=="+doArgs.pkg)
pkgs = pkgs.pkgs.pkg
if pkgs is None or len(pkgs) == 0:
printer.out("No package found")
else:
table = Texttable(800)
table.set_cols_dtype(["t","t","t","t","t","t","t"])
table.header(["Name", "Version", "Arch", "Release", "Build date", "Size", "FullName"])
pkgs = generics_utils.order_list_object_by(pkgs, "name")
for pkg in pkgs:
table.add_row([pkg.name, pkg.version, pkg.arch, pkg.release, pkg.pkgBuildDate.strftime("%Y-%m-%d %H:%M:%S"), size(pkg.size), pkg.fullName])
print table.draw() + "\n"
printer.out("Found "+str(len(pkgs))+" packages")
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: "+str(e), printer.ERROR)
self.help_search()
except Exception as e:
return handle_uforge_exception(e)
def schedule(self, label="default", *argvs, **kwargs):
simulate = kwargs.get("simulate")
reserver = kwargs.get("reserve")
fullInfo = kwargs.get("fullInfo")
if kwargs.get("list"):
tp = TaskPeriod.objects.all()
table = Texttable()
table.set_deco(Texttable.HEADER)
table.header(["Id", "Title", "Label", "Schedule"])
for it in tp:
table.add_row([it.id, it.title, it.label, it.cron])
print(table.draw())
if kwargs.get("template_id"):
template_ids = kwargs.get("template_id")
logger.debug("Schedule template id %s" % template_ids)
filter = {"id__in": template_ids}
self.scheduleByJobTemplates(
filter, label, fullInfo, simulate, reserver)
if kwargs.get("schedule_label"):
period_label = kwargs.get("schedule_label")
filter = {"schedule__label__in": period_label, "is_enable": True}
if not label:
label = period_label
self.scheduleByJobTemplates(
filter, "".join(label), fullInfo, simulate, reserver)
def print_table(prefix, items):
table = Texttable(max_width=160)
table.set_deco(Texttable.HEADER)
table.header(['%s_id' % prefix, '%s_updated' % prefix, '%s_fk' % prefix])
for key, values in items.iteritems():
table.add_row([key, values.get('updated'), values.get('opposite_id')])
print table.draw() + "\n"
def do_list(self, args):
try:
doParser = self.arg_list()
doArgs = doParser.parse_args(shlex.split(args))
printer.out("Getting roles and their entitlements for user [" + doArgs.account + "]:\n")
roles = self.api.Users(doArgs.account).Roles.Getall()
table = Texttable(200)
table.set_cols_align(["l", "l"])
table.header(["Name", "Description"])
table.set_cols_width([30,60])
for role in roles.roles.role:
table.add_row([role.name.upper(), role.description])
for entitlement in role.entitlements.entitlement:
table.add_row(["===> " + entitlement.name, entitlement.description])
printer.out("Role entitlements are represented with \"===>\".", printer.INFO)
print table.draw() + "\n"
return 0
except ArgumentParserError as e:
printer.out("In Arguments: "+str(e), printer.ERROR)
self.help_list()
except Exception as e:
return handle_uforge_exception(e)
def do_list(self, args):
try:
#call UForge API
printer.out("Getting distributions for ["+self.login+"] ...")
distributions = self.api.Users(self.login).Distros.Getall()
distributions = distributions.distributions
if distributions is None or not hasattr(distributions, "distribution"):
printer.out("No distributions available")
else:
table = Texttable(800)
table.set_cols_dtype(["t","t","t","t","t", "t"])
table.header(["Id", "Name", "Version", "Architecture", "Release Date", "Profiles"])
distributions = generics_utils.order_list_object_by(distributions.distribution, "name")
for distribution in distributions:
profiles = self.api.Distributions(distribution.dbId).Profiles.Getall()
profiles = profiles.distribProfiles.distribProfile
if len(profiles) > 0:
profile_text=""
for profile in profiles:
profile_text+=profile.name+"\n"
table.add_row([distribution.dbId, distribution.name, distribution.version, distribution.arch, distribution.releaseDate.strftime("%Y-%m-%d %H:%M:%S") if distribution.releaseDate is not None else "", profile_text])
else:
table.add_row([distribution.dbId, distribution.name, distribution.version, distribution.arch, distribution.releaseDate.strftime("%Y-%m-%d %H:%M:%S") if distribution.releaseDate is not None else "", "-"])
print table.draw() + "\n"
printer.out("Found "+str(len(distributions))+" distributions")
return 0
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: "+str(e), printer.ERROR)
self.help_list()
except Exception as e:
return handle_uforge_exception(e)
def do_delete(self, args):
try:
#add arguments
doParser = self.arg_delete()
try:
doArgs = doParser.parse_args(args.split())
except SystemExit as e:
return
#call UForge API
printer.out("Searching template with id ["+doArgs.id+"] ...")
myAppliance = self.api.Users(self.login).Appliances(doArgs.id).Get()
if myAppliance is None or type(myAppliance) is not Appliance:
printer.out("Template not found")
else:
table = Texttable(800)
table.set_cols_dtype(["t","t","t","t","t","t","t","t","t","t"])
table.header(["Id", "Name", "Version", "OS", "Created", "Last modified", "# Imgs", "Updates", "Imp", "Shared"])
table.add_row([myAppliance.dbId, myAppliance.name, str(myAppliance.version), myAppliance.distributionName+" "+myAppliance.archName,
myAppliance.created.strftime("%Y-%m-%d %H:%M:%S"), myAppliance.lastModified.strftime("%Y-%m-%d %H:%M:%S"), len(myAppliance.imageUris.uri),myAppliance.nbUpdates, "X" if myAppliance.imported else "", "X" if myAppliance.shared else ""])
print table.draw() + "\n"
if doArgs.no_confirm:
self.api.Users(self.login).Appliances(myAppliance.dbId).Delete()
printer.out("Template deleted", printer.OK)
elif generics_utils.query_yes_no("Do you really want to delete template with id "+str(myAppliance.dbId)):
self.api.Users(self.login).Appliances(myAppliance.dbId).Delete()
printer.out("Template deleted", printer.OK)
return 0
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: "+str(e), printer.ERROR)
self.help_delete()
except Exception as e:
return handle_uforge_exception(e)
def print_mapping(prefix, key, items):
table = Texttable(max_width=160)
table.set_deco(Texttable.HEADER)
table.header(['%s_%s' % (prefix, key), '%s_fk' % prefix])
for key, value in items.iteritems():
table.add_row([key, value])
print table.draw() + "\n"
def do_list(self, args):
try:
#call UForge API
printer.out("Getting generation formats for ["+self.login+"] ...")
targetFormatsUser = self.api.Users(self.login).Targetformats.Getall()
if targetFormatsUser is None or len(targetFormatsUser.targetFormats.targetFormat) == 0:
printer.out("No generation formats available")
return 0
else:
targetFormatsUser = generics_utils.order_list_object_by(targetFormatsUser.targetFormats.targetFormat,"name")
table = Texttable(200)
table.set_cols_align(["l", "l", "l", "l", "l", "c"])
table.header(["Name", "Format", "Category", "Type", "CredAccountType", "Access"])
for item in targetFormatsUser:
if item.access:
access = "X"
else:
access = ""
if item.credAccountType is None:
credAccountType = ""
else:
credAccountType = item.credAccountType
table.add_row(
[item.name, item.format.name, item.category.name, item.type, credAccountType,
access])
print table.draw() + "\n"
return 0
except ArgumentParserError as e:
printer.out("In Arguments: " + str(e), printer.ERROR)
self.help_list()
except Exception as e:
return handle_uforge_exception(e)
def do_promote(self, args):
try:
doParser = self.arg_promote()
doArgs = doParser.parse_args(shlex.split(args))
orgSpecified = org_utils.org_get(api=self.api, name=doArgs.org)
adminUser = self.api.Users(doArgs.account).Get()
if adminUser == None:
printer.out("User [" + doArgs.account + "] doesn't exist.", printer.ERROR)
else:
self.api.Orgs(orgSpecified.dbId).Members(adminUser.loginName).Change(Admin=True, body=adminUser)
printer.out("User [" + doArgs.account + "] has been promoted in [" + orgSpecified.name + "] :",
printer.OK)
if adminUser.active == True:
active = "X"
else:
active = ""
printer.out("Informations about [" + adminUser.loginName + "] :")
table = Texttable(200)
table.set_cols_align(["c", "l", "c", "c", "c", "c", "c", "c"])
table.header(
["Login", "Email", "Lastname", "Firstname", "Created", "Active", "Promo Code", "Creation Code"])
table.add_row([adminUser.loginName, adminUser.email, adminUser.surname, adminUser.firstName,
adminUser.created.strftime("%Y-%m-%d %H:%M:%S"), active, adminUser.promoCode,
adminUser.creationCode])
print table.draw() + "\n"
return 0
except ArgumentParserError as e:
printer.out("In Arguments: " + str(e), printer.ERROR)
self.help_promote()
except Exception as e:
return marketplace_utils.handle_uforge_exception(e)
def do_info_draw_publication(self, info_image):
printer.out("Information about publications:")
pimages = self.api.Users(self.login).Pimages.Getall()
table = Texttable(0)
table.set_cols_align(["l", "l"])
has_pimage = False
for pimage in pimages.publishImages.publishImage:
if pimage.imageUri == info_image.uri:
has_pimage = True
cloud_id = None
publish_status = image_utils.get_message_from_status(pimage.status)
if not publish_status:
publish_status = "Publishing"
if publish_status == "Done":
cloud_id = pimage.cloudId
format_name = info_image.targetFormat.format.name
if format_name == "docker" or format_name == "openshift":
cloud_id = pimage.namespace + "/" + pimage.repositoryName + ":" + pimage.tagName
table.add_row([publish_status, cloud_id])
if has_pimage:
table.header(["Status", "Cloud Id"])
print table.draw() + "\n"
else:
printer.out("No publication")
def find_commands(db, *filters):
user_filter = '\s+'.join(filters)
user_re = re.compile(user_filter)
RE_CACHE[user_filter] = user_re
query = '''
SELECT hostname, timestamp, duration, user_string
FROM commands
WHERE timestamp > ? AND user_string REGEXP ?
ORDER BY timestamp
'''
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_cols_align(('l', 'r', 'r', 'l'))
table.header(('host', 'date', 'duration', 'command'))
host_width = 6
max_command_width = 9
now = time.time()
for row in db.execute(query, (TIMESTAMP, user_filter)):
host_width = max(host_width, len(row[0]))
max_command_width = max(max_command_width, len(row[3]))
table.add_row((
row[0],
format_time(row[1], now),
format_duration(row[2]) if row[2] > 0 else '',
highlight(row[3], user_re)))
table.set_cols_width((host_width, 30, 10, max_command_width + 2))
print table.draw()
def do_list(self, args):
try:
#call UForge API
printer.out("Getting templates for ["+self.login+"] ...")
appliances = self.api.Users(self.login).Appliances().Getall()
appliances = appliances.appliances
if appliances is None or not hasattr(appliances, 'appliance'):
printer.out("No template")
else:
images = self.api.Users(self.login).Images.Get()
images = images.images
table = Texttable(800)
table.set_cols_dtype(["t","t","t","t","t","t","t","t","t","t"])
table.header(["Id", "Name", "Version", "OS", "Created", "Last modified", "# Imgs", "Updates", "Imp", "Shared"])
appliances = generics_utils.order_list_object_by(appliances.appliance, "name")
for appliance in appliances:
nbImage=0
if images is not None and hasattr(images, 'image'):
for image in images.image:
if hasattr(image, 'applianceUri') and image.applianceUri == appliance.uri:
nbImage+=1
table.add_row([appliance.dbId, appliance.name, str(appliance.version), appliance.distributionName+" "+appliance.archName,
appliance.created.strftime("%Y-%m-%d %H:%M:%S"), appliance.lastModified.strftime("%Y-%m-%d %H:%M:%S"), nbImage, appliance.nbUpdates, "X" if appliance.imported else "", "X" if appliance.shared else ""])
print table.draw() + "\n"
printer.out("Found "+str(len(appliances))+" templates")
return 0
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: "+str(e), printer.ERROR)
self.help_list()
except Exception as e:
return handle_uforge_exception(e)
def do_disable(self, args):
try:
doParser = self.arg_disable()
doArgs = doParser.parse_args(shlex.split(args))
printer.out("Disabling user [" + doArgs.account + "] ...")
user = self.api.Users(doArgs.account).Get()
if user is None:
printer.out("user " + doArgs.account + "does not exist", printer.ERROR)
else:
if user.active == False:
printer.out("User [" + doArgs.account + "] is already disabled", printer.ERROR)
else:
user.active = False
self.api.Users(doArgs.account).Update(body=user)
printer.out("User [" + doArgs.account + "] is now disabled", printer.OK)
if user.active == True:
actived = "X"
else:
actived = ""
printer.out("Informations about [" + doArgs.account + "] :")
table = Texttable(200)
table.set_cols_align(["c", "l", "c", "c", "c", "c", "c", "c"])
table.header(
["Login", "Email", "Lastname", "Firstname", "Created", "Active", "Promo Code", "Creation Code"])
table.add_row([user.loginName, user.email, user.surname, user.firstName,
user.created.strftime("%Y-%m-%d %H:%M:%S"), actived, user.promoCode, user.creationCode])
print table.draw() + "\n"
return 0
except ArgumentParserError as e:
printer.out("In Arguments: " + str(e), printer.ERROR)
self.help_disable()
except Exception as e:
return marketplace_utils.handle_uforge_exception(e)
def do_info(self, args):
try:
doParser = self.arg_info()
doArgs = doParser.parse_args(shlex.split(args))
printer.out("Getting user ["+doArgs.account+"] ...")
user = self.api.Users(doArgs.account).Get()
if user is None:
printer.out("user "+ doArgs.account +" does not exist", printer.ERROR)
else:
if user.active:
active = "X"
else:
active = ""
printer.out("Informations about " + doArgs.account + ":",)
table = Texttable(200)
table.set_cols_align(["c", "l", "c", "c", "c", "c", "c", "c"])
table.header(["Login", "Email", "Lastname", "Firstname", "Created", "Active", "Promo Code", "Creation Code"])
table.add_row([user.loginName, user.email, user.surname , user.firstName, user.created.strftime("%Y-%m-%d %H:%M:%S"), active, user.promoCode, user.creationCode])
print table.draw() + "\n"
return 0
except ArgumentParserError as e:
printer.out("In Arguments: "+str(e), printer.ERROR)
self.help_info()
except Exception as e:
return handle_uforge_exception(e)
def render_datasets_as_table(datasets, display_heading=True):
"""
Returns ASCII table view of datasets.
:param datasets: The datasets to be rendered.
:type datasets: :class:`mytardisclient.models.resultset.ResultSet`
:param render_format: The format to display the data in ('table' or
'json').
:param display_heading: Setting `display_heading` to True ensures
that the meta information returned by the query is summarized
in a 'heading' before displaying the table. This meta
information can be used to determine whether the query results
have been truncated due to pagination.
"""
heading = "\n" \
"Model: Dataset\n" \
"Query: %s\n" \
"Total Count: %s\n" \
"Limit: %s\n" \
"Offset: %s\n\n" \
% (datasets.url, datasets.total_count,
datasets.limit, datasets.offset) if display_heading else ""
table = Texttable(max_width=0)
table.set_cols_align(["r", 'l', 'l', 'l'])
table.set_cols_valign(['m', 'm', 'm', 'm'])
table.header(["Dataset ID", "Experiment(s)", "Description", "Instrument"])
for dataset in datasets:
table.add_row([dataset.id, "\n".join(dataset.experiments),
dataset.description, dataset.instrument])
return heading + table.draw() + "\n"
def sub(db, command, *filters):
counts = collections.defaultdict(int)
user_filter = ' '.join(itertools.chain([command], filters))
total = 0
query = '''
SELECT user_string
FROM commands
WHERE
timestamp > ?
AND command = ?
'''
for row in db.execute(query, (TIMESTAMP, command)):
command = normalize_user_string(row[0])
if command.startswith(user_filter):
counts[command] += 1
total += 1
percentage = 100 / float(total)
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_cols_align(('r', 'r', 'l'))
table.set_cols_width((5, 6, 75))
table.header(('count', '%', 'command'))
for key, value in sorted(counts.iteritems(), key=lambda (k, v): (v, k), reverse=True)[:20]:
table.add_row((value, value * percentage, key))
print table.draw()
def render_schemas_as_table(schemas, display_heading=True):
"""
Returns ASCII table view of schemas.
:param schemas: The schemas to be rendered.
:type schemas: :class:`mytardisclient.models.resultset.ResultSet`
:param render_format: The format to display the data in ('table' or
'json').
:param display_heading: Setting `display_heading` to True ensures
that the meta information returned by the query is summarized
in a 'heading' before displaying the table. This meta
information can be used to determine whether the query results
have been truncated due to pagination.
"""
heading = "\n" \
"Model: Schema\n" \
"Query: %s\n" \
"Total Count: %s\n" \
"Limit: %s\n" \
"Offset: %s\n\n" \
% (schemas.url, schemas.total_count,
schemas.limit, schemas.offset) if display_heading else ""
table = Texttable(max_width=0)
table.set_cols_align(["r", 'l', 'l', 'l', 'l', 'l', 'l'])
table.set_cols_valign(['m', 'm', 'm', 'm', 'm', 'm', 'm'])
table.header(["ID", "Name", "Namespace", "Type", "Subtype", "Immutable",
"Hidden"])
for schema in schemas:
table.add_row([schema.id, schema.name, schema.namespace,
schema.type, schema.subtype or '',
str(bool(schema.immutable)), str(bool(schema.hidden))])
return heading + table.draw() + "\n"
def render_instruments_as_table(instruments, display_heading=True):
"""
Returns ASCII table view of instruments.
:param instruments: The instruments to be rendered.
:type instruments: :class:`mytardisclient.models.resultset.ResultSet`
:param render_format: The format to display the data in ('table' or
'json').
:param display_heading: Setting `display_heading` to True ensures
that the meta information returned by the query is summarized
in a 'heading' before displaying the table. This meta
information can be used to determine whether the query results
have been truncated due to pagination.
"""
heading = "\n" \
"Model: Instrument\n" \
"Query: %s\n" \
"Total Count: %s\n" \
"Limit: %s\n" \
"Offset: %s\n\n" \
% (instruments.url, instruments.total_count,
instruments.limit, instruments.offset) if display_heading else ""
table = Texttable(max_width=0)
table.set_cols_align(["r", 'l', 'l'])
table.set_cols_valign(['m', 'm', 'm'])
table.header(["ID", "Name", "Facility"])
for instrument in instruments:
table.add_row([instrument.id, instrument.name, instrument.facility])
return heading + table.draw() + "\n"
def make_ssh_fingerprints_table(output):
('Generate a table of SSH fingerprints in reStructuredText for the EOS Lab'
'machines.')
# Enable skip_bad_hosts -- we will list down hosts as such in the table.
#
# skip_bad_hosts and parallel are, unfortunately, mutually exclusive. Don't
# see why they have to be, but that's the way it is.
env.skip_bad_hosts = True
# Generate table.
results_dict = execute(_get_fingerprint)
table = Texttable()
# The default decoration produces the correct table.
table.header(['Host', 'Fingerprint'])
for host, command_output in sorted(six.iteritems(results_dict)):
# Use the short host name.
short_hostname = host.split('.')[0]
fingerprint_text = (
# Indicate that the host is down in the table.
'down for maintenance' if
# Fabric returns the exception if the task failed.
isinstance(command_output, Exception)
# Use a fixed-width font for the fingerprint itself.
else '``{0}``'.format(command_output))
table.add_row((short_hostname, fingerprint_text))
with open(output, 'w') as output_file:
six.print_(table.draw(), file=output_file)
def do_list(self, args):
try:
doParser = self.arg_list()
doArgs = doParser.parse_args(shlex.split(args))
printer.out("Getting entitlements list of the UForge :")
entList = self.api.Entitlements.Getall()
if entList is None:
printer.out("No entitlements found.", printer.OK)
else:
entList=generics_utils.order_list_object_by(entList.entitlements.entitlement, "name")
printer.out("Entitlement list for the UForge :")
table = Texttable(200)
table.set_cols_align(["l", "l"])
table.header(["Name", "Description"])
table.set_cols_width([30,60])
for item in entList:
table.add_row([item.name, item.description])
print table.draw() + "\n"
return 0
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: " + str(e), printer.ERROR)
self.help_list()
except Exception as e:
return handle_uforge_exception(e)
def do_delete(self, args):
try:
# add arguments
doParser = self.arg_delete()
doArgs = doParser.parse_args(shlex.split(args))
#if the help command is called, parse_args returns None object
if not doArgs:
return 2
# call UForge API
printer.out("Searching account with id [" + doArgs.id + "] ...")
account = self.api.Users(self.login).Accounts(doArgs.id).Get()
if account is None:
printer.out("No Account available", printer.WARNING)
else:
table = Texttable(800)
table.set_cols_dtype(["t", "t", "t", "t"])
table.header(["Id", "Name", "Type", "Created"])
table.add_row(
[account.dbId, account.name, account.targetPlatform.name, account.created.strftime("%Y-%m-%d %H:%M:%S")])
print table.draw() + "\n"
if doArgs.no_confirm:
self.api.Users(self.login).Accounts(doArgs.id).Delete()
printer.out("Account deleted", printer.OK)
elif generics_utils.query_yes_no("Do you really want to delete account with id " + str(account.dbId)):
self.api.Users(self.login).Accounts(doArgs.id).Delete()
printer.out("Account deleted", printer.OK)
return 0
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: " + str(e), printer.ERROR)
self.help_delete()
except Exception as e:
return handle_uforge_exception(e)
def do_search(self, args):
try:
#add arguments
doParser = self.arg_search()
try:
doArgs = doParser.parse_args(args.split())
except SystemExit as e:
return
#call UForge API
printer.out("Search package '"+doArgs.pkg+"' ...")
distribution = self.api.Distributions(doArgs.id).Get()
printer.out("for OS '"+distribution.name+"', version "+distribution.version)
pkgs = self.api.Distributions(distribution.dbId).Pkgs.Getall(Search=doArgs.pkg, Version=distribution.version)
if pkgs is None or not hasattr(pkgs, 'pkgs'):
printer.out("No package found")
else:
table = Texttable(800)
table.set_cols_dtype(["t","t","t","t","t","t"])
table.header(["Name", "Version", "Arch", "Release", "Build date", "Size"])
pkgs = generics_utils.oder_list_object_by(pkgs.get_pkgs().get_pkg(), "name")
for pkg in pkgs:
table.add_row([pkg.name, pkg.version, pkg.arch, pkg.release, pkg.pkgBuildDate.strftime("%Y-%m-%d %H:%M:%S"), size(pkg.size)])
print table.draw() + "\n"
printer.out("Found "+str(len(pkgs))+" packages")
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: "+str(e), printer.ERROR)
self.help_search()
except Exception as e:
generics_utils.print_uforge_exception(e)
def get_hard_drive_list_table(self):
"""Return a table of hard drives"""
# Manually set permissions asserted, as this function can
# run high privilege calls, but doesn't not require
# permission checking
self._get_registered_object('auth').set_permission_asserted()
# Create table and set headings
table = Texttable()
table.set_deco(Texttable.HEADER | Texttable.VLINES)
table.header(('ID', 'Size', 'Type', 'Storage Backend', 'Virtual Machine'))
table.set_cols_width((50, 15, 15, 50, 20))
# Obtain hard ives and add to table
for hard_drive_obj in self.get_all():
vm_object = hard_drive_obj.get_virtual_machine()
hdd_type = ''
storage_backend_id = 'Storage backend does not exist'
try:
storage_backend_id = hard_drive_obj.storage_backend.id_
hdd_type = hard_drive_obj.get_type()
hdd_size = SizeConverter(hard_drive_obj.get_size()).to_string()
except (VolumeDoesNotExistError,
HardDriveDoesNotExistException,
StorageBackendDoesNotExist), exc:
hdd_size = str(exc)
table.add_row((hard_drive_obj.id_, hdd_size,
hdd_type, storage_backend_id,
vm_object.get_name() if vm_object else 'Not attached'))
def list_modules(driver, extension, pattern):
drvcls = loadmodules(driver, extension)
from texttable import Texttable
table = Texttable()
table.set_cols_align(["l", "l"])
# table.set_deco(Texttable.HEADER)
table.header(["Module", "Description"])
mods = drvcls.listmodule()
for k in sorted(mods.keys()):
if pattern is not None and k.find(pattern) == -1:
continue
table.add_row([k, mods[k]])
print(table.draw())
def make_new():
table = Texttable(max_width=80)
table.set_deco(Texttable.HEADER)
table.set_cols_width(
[
max([chrsize_len(str(c)) for c in gs["timed_role"].keys()]),
max([chrsize_len(str(to_lts(c))) for c in gs["timed_role"].values()]),
]
)
table.set_cols_dtype(["t", "t"])
table.set_cols_align(["l", "l"])
table.add_row(get_txt(ctx.guild.id, "tr_list_row"))
return table
def stacks(args):
client = AWS.current_session().client('cloudformation')
stacks = client.describe_stacks()
table = Texttable(max_width=150)
table.add_rows([STACK_HEADERS])
for stack in stacks['Stacks']:
table.add_row([
stack['StackName'], stack['CreationTime'],
stack.get('LastUpdatedTime', ''), stack['StackStatus']
])
logger.info("Current Stacks:\n" + table.draw() + "\n")
def showBoard(self, player, board):
table = Texttable()
table.set_deco(GameController.textTableDecorator)
board = self.boardRepository.getBoard(player, board)
table.add_row([""] + Board.columns)
for rowNumber in range(Board.dimension):
rowString = str(rowNumber)
line = [rowString]
for column in Board.columns:
line.append(board.getMark(column + rowString))
table.add_row(line)
return table.draw()
def migration_table(migrations):
table = Texttable(800)
table.set_cols_dtype(["t", "t", "t"])
table.set_cols_align(["c", "l", "c"])
table.header(["Id", "Name", "Status"])
for migration in migrations:
status = migration.status.message + " (" + str(migration.status.percentage) + "%)"
if migration.status.complete or migration.status.error or migration.status.cancelled:
status = migration.status.message
table.add_row([migration.dbId, migration.name, status])
return table
def __str__(self):
table = Texttable()
for particle in self.__particles:
for individual in particle.position:
row = []
for column in range(len(individual)):
row.append(
str(individual.first[column]) + ", " +
str(individual.second[column]))
table.add_row(row)
return table.draw()
def retrieve_channels():
table = Texttable()
table = table.header(['ID', 'Channel title', 'Username'])
table = table.set_cols_width([12, 32, 33])
table = table.set_cols_dtype(['t', 't', 't'])
print('Retrieving dialogs...')
for dialog in client.iter_dialogs():
if dialog.is_channel:
_id = str(dialog.entity.id)
title = dialog.title
username = '******' + dialog.entity.username
table.add_row([_id, title, username])
print(table.draw())
def __str__(self):
#Debug purposes
t = Texttable()
for i in range(self._h):
t.add_row(self._data[i])
print(t.draw())
#until here
t = Texttable()
for i in range(self._h):
t.add_row(self._reveal[i])
return t.draw()
def table_mutation_types(self, genedr):
table = Texttable(LINE_WIDTH)
for muttype in genedr['mutation_types']:
# len(cols) == 2
row = [muttype['label']]
muts = [
mut['text'].replace('*', '\*').replace('_', '\_')
for mut in genedr['mutations']
if mut['type'] == muttype['name']
]
row.append(', '.join(muts) or 'None')
table.add_row(row)
return table.draw()
def lsshare(lsDir):
try:
session = connect()
output = session.get_shares(path=lsDir, subfiles=True)
t = Texttable()
t.header(["Path", "Token", "Date Created"])
for i in output:
t.add_row([i.get_path(), i.get_token(), i.get_share_time()])
t.set_deco(t.VLINES | t.HEADER)
print(t.draw())
except Exception as e:
print("ERR: " + str(e) + "\n\nStack Trace:\n")
print(traceback.format_exc())
def print_onnx_graph(self):
t = Texttable(max_width=180)
t.add_row(['lay_num', 'input_node', 'output_node', 'node_type'])
dims = self.get_conv_dims()
lay_num = 0
for layer in self.parsed_graph:
t.add_row([lay_num,
layer['input_node'],
layer['output_node'],
layer['node_type']])
lay_num += 1
print("Onnx Model Graph:")
print(t.draw())
def output_object(items):
table = Texttable(max_width=get_terminal_size()[1])
table.set_deco(Texttable.BORDER | Texttable.VLINES)
for i in items:
if len(i) == 3:
name, _, value = i
table.add_row([name, TableOutputFormatter.format_value(value, ValueType.STRING)])
if len(i) == 4:
name, _, value, vt = i
table.add_row([name, TableOutputFormatter.format_value(value, vt)])
print table.draw()
def __str__(self):
table = Texttable()
header = [""]
header.extend(range(self.__n))
table.header(header)
for noOfRow in range(self.__n):
row = [str(noOfRow) + ")"]
row.extend(self.getRow(noOfRow))
table.add_row(row)
return table.draw()
def cmd_list(nexus_client):
"""Performs ``nexus3 repository list``"""
repositories = nexus_client.repositories.raw_list()
table = Texttable(max_width=util.TTY_MAX_WIDTH)
table.add_row(['Name', 'Format', 'Type', 'URL'])
table.set_deco(Texttable.HEADER)
for repo in repositories:
table.add_row(
[repo['name'], repo['format'], repo['type'], repo['url']])
print(table.draw())
return exception.CliReturnCode.SUCCESS.value
def display_similarities(comparisons):
"""
Method that display the matches in the comparisons
:param comparisons: a list of triples (device1, device2, sign)
"""
table = Texttable()
table.set_cols_width([30, 30, 30])
table.header(['Device 1', 'Device 2', 'Signature'])
for triple in comparisons:
table.add_row([triple[0], triple[2], triple[1]])
print(bcolors.HEADER + 'Similarities: ' + bcolors.ENDC)
print(table.draw())
def __print_table(self, header, rows):
if self.__clean_print:
print(", ".join(header))
for r in rows:
print(", ".join(r))
else:
#Pretty Print
table = TextTable(max_width=shutil.get_terminal_size((80,
20)).columns)
table.header(header)
for r in rows:
table.add_row(r)
print(table.draw())
def display_nets(muxes, netname):
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_cols_dtype(['t', 't', 't'])
table.set_cols_align(['l', 'r', 'r'])
table.add_row(['name', 'type', 'channel'])
for mux in muxes:
for mapping in mux['mappings']:
if netname is None or netname == mapping['net']:
channel = channel_num(mux, mapping)
table.add_row([mapping['net'], mux['role'], channel])
click.echo(table.draw())
def read_JSON(pokemon):
# Open and load json file for reading.
file = open(('DATA/' + pokemon.upper() + "/" + pokemon.upper()))
data = json.load(file)
# Extract Pokemon name and Pokedex Id from API data.
id = data['id']
name = data['name']
# Extract the type(s). Pokemon could either have 1-2 types.
type1 = data['types'][0]['type']['name']
type2 = data['types'][1]['type']['name'] if len(data['types']) == 2 else 0
types = [type1, type2] if len(data['types']) == 2 else [type1]
# Extract the relevant stats for this pokemon.
stats = data['stats']
speed = stats[0]['base_stat']
spDefence = stats[1]['base_stat']
spAttack = stats[2]['base_stat']
defence = stats[3]['base_stat']
attack = stats[4]['base_stat']
hp = stats[5]['base_stat']
totalStats = speed + spDefence + spAttack + defence + attack + hp
# Height and Weight for Pokemon; Convert API data to lbs and metres.
weight = data['weight'] * 0.220462
height = data['height'] * 0.1
# Link to the image for this pokemon.
image = data['sprites']['front_default']
# Create and display table containing information relating to that particular pokemon.
table = Texttable()
table.add_row(['ID', 'NAME', 'TYPE(S)', 'HP', 'ATK', 'DEF', 'SP. ATK', 'SP. DEF', 'SPD',
'HEIGHT \n(m)', 'WEIGHT \n(lbs)', 'TOTAL'])
table.add_row([id, name.upper(), str(types)[1:-1].upper().replace("'", ''), hp, attack, defence, spAttack, spDefence, speed,
height, weight, totalStats])
table.set_cols_width([4, 15, 20, 4, 4, 4, 4, 4, 4, 6, 8, 6])
print(table.draw())
# Format height and weights decimal points (limit to 2 decimal places).
weight_Format = "%.2f" % weight
height_Format = "%.2f" % height
values = {'id': id, 'name': name.upper(), 'type': types, 'hp': hp, 'attack': attack, 'defence': defence, 'spAttack': spAttack,
'spDefence': spDefence, 'speed': speed, 'height': height_Format,
'weight': weight_Format, 'totalStats': totalStats, 'imageUrl': image}
# Return dictionary containing all relevant information of interest from json.
return values
def do_list(self, args):
try:
#call UForge API
printer.out("Getting distributions for [" + self.login + "] ...")
distributions = self.api.Users(self.login).Distros.Getall()
distributions = distributions.distributions
if distributions is None or not hasattr(distributions,
"distribution"):
printer.out("No distributions available")
else:
table = Texttable(800)
table.set_cols_dtype(["t", "t", "t", "t", "t", "t"])
table.header([
"Id", "Name", "Version", "Architecture", "Release Date",
"Profiles"
])
distributions = generics_utils.order_list_object_by(
distributions.distribution, "name")
for distribution in distributions:
profiles = self.api.Distributions(
distribution.dbId).Profiles.Getall()
profiles = profiles.distribProfiles.distribProfile
if len(profiles) > 0:
profile_text = ""
for profile in profiles:
profile_text += profile.name + "\n"
table.add_row([
distribution.dbId, distribution.name,
distribution.version, distribution.arch,
distribution.releaseDate.strftime(
"%Y-%m-%d %H:%M:%S")
if distribution.releaseDate is not None else "",
profile_text
])
else:
table.add_row([
distribution.dbId, distribution.name,
distribution.version, distribution.arch,
distribution.releaseDate.strftime(
"%Y-%m-%d %H:%M:%S") if
distribution.releaseDate is not None else "", "-"
])
print table.draw() + "\n"
printer.out("Found " + str(len(distributions)) +
" distributions")
return 0
except ArgumentParserError as e:
printer.out("ERROR: In Arguments: " + str(e), printer.ERROR)
self.help_list()
except Exception as e:
return handle_uforge_exception(e)
def print_docs_that_contain_word(dataset: StructuredDataset,
word: str,
num_chars_preview=70):
"""
Prints a table with the following properties of all documents in the dataset that contain the given word:
- Category name
- Index inside the document list of that category (in the dataset.files_dict)
- Number of words of that document
- Number of occurrences of the word in that document
- Document name in the dataset
- Preview of the document content
:param dataset: Dataset.
:param word: Word contained in the printed documents.
:param num_chars_preview: Number of characters to show in the preview column.
"""
# Create table for better printing
table = Texttable()
table.set_cols_width([30, 15, 10, 15, 10, num_chars_preview])
table.set_cols_align(['c', 'c', 'c', 'c', 'c', 'l'])
# Specify header
table.set_header_align(['c', 'c', 'c', 'c', 'c', 'c'])
table.header([
'Category name', 'Doc index inside category list of docs', 'Num words',
'Num occurrences of given word', 'Document name', 'Content preview'
])
num_docs_contain_word = 0
for category_name, category_docs in dataset.files_dict.items():
doc_index_in_category = 0
for doc in category_docs:
doc_words = doc.content.split()
if word in doc_words:
num_docs_contain_word += 1
num_words_in_doc = len(doc_words)
num_word_occurences_in_doc = doc_words.count(word)
# Add row for each doc that contain the given word
table.add_row([
category_name,
doc_index_in_category,
num_words_in_doc,
num_word_occurences_in_doc,
doc.name,
# TODO: Instead of showing the first k characters, it would be better to show text around the word
doc.content[:num_chars_preview]
])
doc_index_in_category += 1
print(table.draw())
print(" Num docs with the word " + word + ":", num_docs_contain_word)
def delContact(cur, con):
try:
name = input(
"Search for the customer name whose contact you want to delete(Simply press enter if you want to see the whole list) : "
)
SearchCust(name, cur, con)
cust_id = int(
input("Enter the customer ID whose contact you want to delete : "))
cur.execute("SELECT * FROM CONTACT WHERE cust_id=%s", (cust_id))
cust = []
todelete = []
table = Texttable()
table.header(["S.No.", "Phone"])
table.set_cols_dtype(["i", "t"])
for i, row in enumerate(cur):
cust.append(row)
table.add_row([i + 1, row['phone']])
if len(cust) == 0:
raise Exception("This customer has no contacts stored!")
print(table.draw())
while (len(todelete) <= len(cust)):
sno = input(
"Enter the Sno of the Phone no. you want to delete, leave blank to quit(proceed) :"
)
if sno and int(sno) > 0:
sno = int(sno)
todel = cust[sno - 1]
if (todel in todelete):
print("Number already selected for deletion!")
continue
else:
todelete.append(todel)
cur.execute(
"DELETE FROM CONTACT WHERE cust_id=%s AND phone=%s",
(cust_id, todel['phone']))
continue
else:
break
if (len(todelete) > 0):
ch = input(
"Are you sure you want to delete the selected numbers? (y/N)")
if (ch.lower() == 'y'):
con.commit()
print("Contacts deleted!")
else:
con.rollback()
print("Contacts were not deleted.")
except Exception as e:
con.rollback()
print("Failed to delete contacts from database")
print(">>>>>>>>>>>>>", e)
def main(self):
from texttable import Texttable
from egtlib.utils import format_duration, format_td
import shutil
termsize = shutil.get_terminal_size((80, 25))
table = Texttable(max_width=termsize.columns)
table.set_deco(Texttable.HEADER)
table.set_cols_align(("l", "l", "r", "c", "r"))
table.add_row(("Name", "Tags", "Logs", "Hrs", "Last entry"))
e = self.make_egt(self.args.projects)
projs = e.projects
blanks = []
worked = []
for p in projs:
if p.last_updated is None:
blanks.append(p)
else:
worked.append(p)
blanks.sort(key=lambda p: p.name)
worked.sort(key=lambda p: p.last_updated)
now = datetime.datetime.now()
def add_summary(p):
table.add_row((
p.name,
" ".join(sorted(p.tags)),
len(list(p.log.entries)),
format_duration(p.elapsed, tabular=True)
if p.last_updated else "--",
"%s ago" % format_td(now - p.last_updated, tabular=True)
if p.last_updated else "--",
))
# res["mins"] = self.elapsed
# res["last"] = self.last_updated
# res["tags"] = self.tags
# res["entries"] = len(self.log)
# #"%s" % format_duration(mins),
# #format_td(datetime.datetime.now() - self.last_updated)),
# print "%s\t%s" % (self.name, ", ".join(stats))
for p in blanks:
add_summary(p)
for p in worked:
add_summary(p)
print(table.draw())
def _setup_table():
table = Texttable(max_width=CELL_WIDTH)
table.add_row([
NAME_LABEL,
Stat.PLAYED.value,
Stat.WON.value,
Stat.DRAW.value,
Stat.LOST.value,
Stat.GOALS_FOR.value,
Stat.GOALS_AGAINST.value,
Stat.POINTS.value,
Stat.POINTS_ADJUSTED.value,
])
return table
def __repr__(self):
t = Texttable()
l = []
d = {-1: 'Y', 0: ' ', 1: 'B'}
for i in range(0, 42, 7):
row = self._data[i:i + 7]
for j in range(7):
row[j] = d[row[j]]
l.append(row)
s = len(l) - 1
while s > -1:
t.add_row(l[s])
s -= 1
return t.draw()
def __str__(self):
from ..formatters import to_format
table = Texttable(max_width=0)
table.set_chars(self.__border__())
data = self.to_array()
for sub_array in data:
new_array = []
for item in sub_array:
if item == "":
new_array.append(" ")
else:
new_array.append(to_format(str, item))
table.add_row(new_array)
return table.draw()
def search_tweet():
api = TwitterClient()
t = Texttable()
print('\n1) Search by keyword\n2) Search by username')
choice = int(input('Enter choice: '))
if (choice == 1):
q = str(input('Enter a Name to Search: '))
nu = int(input('\nEnter the number of tweets to fetch: '))
tweets = api.get_tweets(query=q, count=100)
i = 1
t.add_row(['', 'Tweets'])
for tweet in tweets[:nu]:
t.add_row([i, tweet['text']])
i += 1
print t.draw()
elif (choice == 2):
extractor = twitter_setup()
q = str(input('Enter a Name to Search: '))
nu = int(input('\nEnter the number of tweets to fetch: '))
try:
tweets = extractor.user_timeline(screen_name=q, count=100)
t.add_row(['', 'Tweets'])
i = 1
for tweet in tweets[:nu]:
t.add_row([i, tweet.text])
i += 1
print t.draw()
except:
print('User not found')
sys.stdin.read(1)
def analyze_tweets():
api = TwitterClient()
q = input('Enter a Name to Search: ')
tweets = api.get_tweets(query=q, count=1000)
ptweets = [tweet for tweet in tweets if tweet['sentiment'] == 'positive']
print("\n\nGood tweets percentage: {} %".format(100 * len(ptweets) /
len(tweets)))
ntweets = [tweet for tweet in tweets if tweet['sentiment'] == 'negative']
print("\n\nBad tweets percentage: {} %".format(100 * len(ntweets) /
len(tweets)))
print("\n\nUnbiased tweets percentage: {} %".format(
100 * (len(tweets) - len(ntweets) - len(ptweets)) / len(tweets)))
t1 = Texttable()
t2 = Texttable()
print "\n\n"
t1.add_row(['Good Tweets'])
for tweet in ptweets[:10]:
t1.add_row([tweet['text']])
print t1.draw()
print "\n\n"
t2.add_row(['Bad Tweets'])
for tweet in ntweets[:10]:
t2.add_row([tweet['text']])
print t2.draw()
sys.stdin.read(1)
def stack_bash():
t = Texttable()
t.add_row(["Menu"])
t.add_row(["1: Search For Answer for a Question"])
t.add_row(["2: Search For Questions Similar to the Question"])
t.add_row(["3: Exit"])
print(t.draw())
while True:
g = input("Enter your Choice : ")
if re.search('[^0-9]', g) != None or not g:
print("Enter Valid Option")
continue
g = int(g, 10)
if g == 3:
break
else:
if g == 1:
ques = input(
"Enter The Question that you want to Search : ")
print(get_answers(str(ques)) + "\n")
# print ques
elif g == 2:
ques = input(
"Enter The Question that you want to Search : ")
# print ques
print(similar_questions_search(str(ques)) + "\n")
else:
print("Enter Valid Option")
def __str__(self):
t = Texttable()
d = {
0: " ",
1: "s",
2: "X",
3: "o"
} #x apare unde a lovit calculatorul barca si nu a nimerit
for i in range(0, 8):
list = self.tabla[i][:]
for j in range(0, 8):
list[j] = d[list[j]]
t.add_row(list)
return t.draw()
def afisareTablaComputer(self):
t = Texttable()
d = {
0: " ",
1: "h",
2: "X",
3: "o"
} #o apare unde a lovit player-ul pe tabla computerului si a nimerit
for i in range(0, 8):
list = self.tabla[i][:]
for j in range(0, 8):
list[j] = d[list[j]]
t.add_row(list)
return t.draw()
