def get_args():
parser = ArgumentParser.ArgumentParser()
parser.addArgument("-i", str)
parser.addArgument('-o', str, default=join(getcwd(), "ASCIIGen_out.txt"))
parser.addArgument('--charset', str, default='@%#*+=-:. ')
parser.addArgument("--res", float, default=1)
return parser.parseArguments()
def main():
args = ArgumentParser.ArgumentParser()
parser = Resolver.Resolver(args.ipaddr, args.verbosity)
resolved_ips = parser.getResolvedIps()
if args.output:
outfile = args.output
else:
outfile = False
try:
if (isinstance(resolved_ips, list)):
if not resolved_ips:
sys.stderr.write(
'[-] Could not resolve any ips... Exiting...\n\n')
exit()
ipsTraced = []
locations = []
lattitudes = []
longtitudes = []
orgs = []
print('\n\n[*] Resolved Ips: {0}'.format(len(resolved_ips)))
for ip in resolved_ips:
loc, lat, lon, org = printResults(ip, args.verbosity,
args.accurate, outfile)
if args.visual:
ipsTraced.append(ip)
locations.append(loc)
lattitudes.append(lat)
longtitudes.append(lon)
orgs.append(org)
if args.visual:
visualcreator.create(ipsTraced, locations, lattitudes,
longtitudes, orgs, args.visual,
args.mobile)
else:
if not resolved_ips:
sys.stderr.write(
'[-] Could not resolve any ips... Exiting...\n\n')
exit()
print('\n\nResolved Ip: {0}'.format(resolved_ips))
loc, lat, lon, org = printResults(resolved_ips, args.verbosity,
args.accurate, outfile)
if args.visual:
visualcreator.create(resolved_ips, loc, lat, lon, org,
args.visual, args.mobile)
print('\n\n')
printBannerPadding()
print('\n\n')
print('[+] Trace Completed Successfully!')
finally:
if outfile:
outfile.close()
def parse_args(self, string):
print("got ", string)
if string == "":
return self.random()
parser = ArgumentParser.ArgumentParser()
pos_args = parser.add_argument_group("Positional arguments")
opt_args = parser.add_argument_group("Optional arguments")
pos_args.add_argument(
"subreddit",
type=str,
help="The subreddit you want to download the image from",
default="memes")
opt_args.add_argument('-a',
"--amount",
type=int,
help="The amount of images you want to download",
required=False,
default=1)
opt_args.add_argument('-t',
"--time",
type=str,
help="Time frame",
choices=["h", "d", "w", "m", "y"],
required=False,
default="h")
opt_args.add_argument('-o',
"--order",
type=str,
help="Order",
choices=["new", "top", "hot"],
required=False)
try:
args = parser.parse_args(string.split())
except SystemExit as e:
# print(e)
return {
"media": "error",
"text": self.usage_message,
"media_location": ""
}
self.sub = args.subreddit
self.amount = args.amount
self.time = args.time
self.order = args.order
self.images_path = f'commands/m/images/{self.sub}/'
if self.order == None or self.order == "top":
return self.top()
elif self.order == "new":
return self.new()
elif self.order == "hot":
return self.hot()
def get_args():
parser = ArgumentParser.ArgumentParser()
parser.addArgument('-i', str)
parser.addArgument('-o', str, default=join(getcwd(), "ASCIIGen_out.png"))
parser.addArgument('--charset', str, default='@%#*+=-:. ')
parser.addArgument('--res', float, default=2)
parser.addArgument('--scale', float, default=2.5)
parser.addArgument('--bg',
str,
default="white",
choices=["white", "black", "transparent"])
return parser.parseArguments()
def main():
arg = ArgumentParser.ArgumentParser()
arg.do_parsing()
torrent_dict = decode_from_file(os.getcwd() + "\\" + arg.torrent_file_url)
info_dict = torrent_dict[b"info"]
piece_length = info_dict[b"piece length"]
piece_count = int(len(info_dict[b"pieces"])/20)
file_name = info_dict[b"name"]
file_name = file_name.decode("utf-8")
if b"files" in info_dict:
print(info_dict[b"files"])
global chunk_number
chunk_number = int(piece_length/chunk_size)
if piece_length % chunk_size != 0:
chunk_number += 1
global pieces_bitfield
pieces_bitfield = [None] * piece_count
global currently_used
currently_used = [False] * piece_count
dictionary_sha1 = helper.get_sha1(encode(info_dict))
bencoded_info_dict = encode(info_dict)
info_hash = helper.get_sha1(bencoded_info_dict)
peer_id = os.urandom(20)
listen_port = 2710
file_length = info_dict[b"length"]
payload = {"info_hash": info_hash, "peer_id": peer_id,
"port": listen_port, "uploaded": 0, "downloaded": 0, "left": file_length}
r = requests.get(torrent_dict[b"announce"], params=payload)
response = decode(r.content)
if b"failure reason" in response:
return
interval = response[b"interval"]
peers = response[b"peers"]
peers_list = []
peer_num = len(peers)/6
for elem in range(int(peer_num)):
start_ind = 6 * elem
peer_ip = socket.inet_ntoa(peers[start_ind:start_ind+4])
peer_port = struct.unpack("!H", peers[start_ind+4:start_ind+6])[0]
peers_list.append((peer_ip, peer_port))
print(peers_list)
for elem in peers_list:
test_ip = elem[0]
test_port = elem[1]
cur_thread = Thread(target=do_for_each_peer,
args=(dictionary_sha1, test_ip, test_port, piece_length, info_dict, peer_id, file_length,
file_name))
# do_for_each_peer(dictionary_sha1, test_ip, test_port, piece_length, info_dict,peer_id)
# print(cur_thread.name)
cur_thread.start()
import ArgumentParser
from NeuralNet import *
from Config import Config
import tflowtools as TFT
import sys
from CaseManager import *
import numpy as np
import mnist.mnist_basics as mnist
from Case import *
import CSVReader
if __name__ == '__main__':
args = ArgumentParser.parseArgs()
config = Config(args)
caseManager = CaseManager(
config,
cfunc=lambda: config.src_function(*config.src_args
), # * unpacks list arguments
vfrac=config.vfrac,
tfrac=config.tfrac,
case_fraction=config.case_fraction,
src_function=config.src_function,
src_args=config.src_args,
src_path=config.src_file_path)
nn = NeuralNet(config, caseManager)
nn.do_training()
# nn.do_testing()
# TFT.fireup_tensorboard('probeview')
def parse_options():
description = "perform scan via saprouter"
usage = "%(prog)s [options] -d <remote host>"
parser = ArgumentParser(usage=usage,description=description,epilog=pysap.epilog)
target = parser.add_argument_group("target")
target.add_argument("-d","--remote-host",dest="remote_host",default="196.168.50.46",help="Remote host [%(default)d]")
target.add_argument("-p","--remote-port",dest="remote_port",type=int,default=3299,help="Remote port[%(default)d]")
target.add_argument("-t","--target-hosts",dest="target_hosts",help="Targets host to scan")
target.add_argument("-r","--target-ports",dest="target_ports",help="Target_ports to scan")
target.add_argument("--router-version",dest="router_version",type=int,help="Router_version")
target.add_argument("--talk-mode",dest="talk_mode",default=raw,help="Talk mode to use when requesting route(raw or ni [%(default)d]")
misc = parser.add_argument_group("misc options")
misc.add_argument("-v","--verbose",dest="verbose",action="store_true",help="verbose output")
options = parser.parser_args()
if not options.remote_host:
parser.error("Remote host required")
if not options.target_hosts:
parser.error("target hosts required")
if not options.target_ports:
parser.error("target ports required")
options.talk_mode = options.talk_mode.lower()
if options.talk_mode not in ["raw","ni"]:
parser.error("Invalid talk mode")
return options
super(MyWF, self).finalize()
self.check_tt()
self.tt.finalize()
self.logger.info("Finalized.")
if __name__ == "__main__":
print("Hello NG.")
# Handle the arguments.
args = ArgumentParser.args
# Handle the crop settings.
cropTrain = ArgumentParser.convert_str_2_int_list( args.dl_crop_train )
cropTest = ArgumentParser.convert_str_2_int_list( args.dl_crop_test )
# Handle the resize settings.
newSize = ArgumentParser.convert_str_2_int_list( args.dl_resize )
print_delimeter(title = "Before WorkFlow initialization." )
try:
# Instantiate an object for MyWF.
wf = MyWF(args.working_dir, prefix=args.prefix, suffix=args.suffix, disableStreamLogger=False)
wf.verbose = False
# Cross reference.
tt = TrainTestPWCNetStereo(wf.workingDir, wf)
wf.set_tt(tt)
from view import ParsingError
random = _random.WichmannHill()
# edit and die. if you want to help with this script, open a PR on github.
ScriptName = "IF parameters"
Website = None
Version = "2.0.3"
Creator = "TMHK"
Description = "fixed obs parameters"
Parent = None
filedata = os.path.join(os.path.dirname(__file__), "cache")
varfile = os.path.join(filedata, "vars.json")
variables = {}
last_save_time = time.time()
argparser = ArgumentParser.Adapter() # create my argparser instance.
controller = None # i will set this once we have the Parent at our disposal.
def send_message(message, data=None):
"""
helper to send messages. nothing crazy.
"""
message = message.replace("$currencyname", Parent.GetCurrencyName())
if data:
message = message.replace("$user", data.UserName)
for i in range(1, data.GetParamCount() - 1):
message = message.replace("$arg" + str(i), data.GetParam(i))
if data:
if data.IsFromDiscord():
Parent.SendDiscordMessage(message)
#!/usr/bin/env python3
import ArgumentParser
import QuantumProgramRunner
if __name__ == "__main__":
QuantumProgramRunner.run(ArgumentParser.parseArgs())
