def crear_tablas():
init(autoreset=True)
auth = app.auth
if os.path.exists(DATABASE['name']):
print Fore.GREEN + 'Creando el archivo ' + DATABASE['name']
os.remove(DATABASE['name'])
# Crear tablas
auth.User.create_table(fail_silently=True)
def es_un_modelo(clase):
return inspect.isclass(c) and issubclass(c, models.db.Model)
for nombre, clase in [(n, c) for n, c in inspect.getmembers(models) if es_un_modelo(c)]:
clase.create_table(fail_silently=True)
print Fore.GREEN + 'Creando tabla para ' + nombre
#Crear usuario admin
admin = auth.User(username='******', admin=True, active=True)
admin.set_password('admin')
admin.save()
print Fore.GREEN + "Creando usuario admin"
cargar_provincias()
def main():
# log settings
# log format
# logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
colorama.init()
config = init_config()
if not config:
return
logger.log('[x] PokemonGO Bot v1.0', 'green')
logger.log('[x] Configuration initialized', 'yellow')
try:
bot = PokemonGoBot(config)
bot.start()
logger.log('[x] Starting PokemonGo Bot....', 'green')
while True:
bot.take_step()
except KeyboardInterrupt:
logger.log('[x] Exiting PokemonGo Bot', 'red')
def index(self):
"""arg list"""
init(autoreset=True)
parser = argparse.ArgumentParser(description=
'Mongodb unauthorized access vulnerability PoC')
group = parser.add_mutually_exclusive_group()
group.add_argument('-i', help='IP', dest='ip')
group.add_argument('-s', help='class C network segment', dest='segment')
group.add_argument('-f', help='IP file', dest='ip_file')
parser.add_argument('-n', help='thread num', dest='thread_num', default=10)
args = parser.parse_args()
q = Queue.Queue()
if args.ip:
self.connect_mongo(args.ip)
elif args.segment:
for i in xrange(0, 255):
ip = args.segment.rpartition('.')[0] + '.' + str(i)
q.put(ip)
self.start_thread(q, args.thread_num)
elif args.ip_file:
with open(args.ip_file, 'r') as f:
for ip in f:
q.put(ip)
self.start_thread(q, args.thread_num)
def __init__(self, *args, **kwargs):
'''
Constructor
'''
init(autoreset=True)
self.unfinished_solicitations_by_sn = {}
super(NsfSpider, self).__init__(*args, **kwargs)
def scan(only_changed_files=False, progress=True, stylo=False):
# check config file for errors
config_errors = check_config_file(CONFIG_FILE_PATH)
# check directories contain expected files
directory_errors = check_directory_files(config['check_ext'])
# standard checks
files_to_check = filter_files('.', only_changed_files and not stylo, progress)
checking_functions = (check_flake8, check_lock, check_webidl_spec, check_json, check_yaml)
line_checking_functions = (check_license, check_by_line, check_toml, check_shell,
check_rust, check_spec, check_modeline)
file_errors = collect_errors_for_files(files_to_check, checking_functions, line_checking_functions)
# check dependecy licenses
dep_license_errors = check_dep_license_errors(get_dep_toml_files(only_changed_files), progress)
# other lint checks
lint_errors = run_lint_scripts(only_changed_files, progress, stylo=stylo)
# chain all the iterators
errors = itertools.chain(config_errors, directory_errors, lint_errors,
file_errors, dep_license_errors)
error = None
for error in errors:
colorama.init()
print "\r\033[94m{}\033[0m:\033[93m{}\033[0m: \033[91m{}\033[0m".format(*error)
print
if error is None:
colorama.init()
print "\033[92mtidy reported no errors.\033[0m"
return int(error is not None)
def expire_files():
'''
FILE CLEANUP ROUTINE
This function will run on a schedule set by FILE_CLEANUP SCHEDULE
in config.py.
Running this function will delete all files that have expired as
determined by EXPIRE_TIME in config.py
'''
colorama.init()
green = colorama.Fore.GREEN
yellow = colorama.Fore.YELLOW
red = colorama.Fore.RED
reset = colorama.Fore.RESET
print(green + " -- FILE CLEANUP STARTED -- " + reset)
for root, dirs, files in os.walk(config.UPLOAD_DIR):
for name in files:
file_time = os.path.getmtime(os.path.join(root, name))
expire_time = file_time + config.EXPIRE_TIME * 60 * 60
current_time = time.time()
if current_time > expire_time:
os.remove(os.path.join(root, name))
print(red + "removed: " + os.path.join(root, name) + reset)
for name in dirs:
try:
os.rmdir(os.path.join(root, name))
print(red + "Removed: " + os.path.join(root, name) + reset)
except OSError as e:
if e.errno == errno.ENOTEMPTY:
print(yellow + os.path.join(root, name) + " is not empty" + reset)
print(green + " -- FILE CLEANUP COMPLETED -- " + reset)
def dostatus(context, show_down_services):
init()
b = BColors()
up_processes_table = PrettyTable()
up_processes_table.field_names = ["name", "ppid", "pid", "uptime", "mem", "port", "test id", "run from", "features", "healthcheck"]
up_processes_table.align = "r"
up_processes_table.align["name"] = "l"
up_processes_table.sortby = "name"
up_processes_table.align["test id"] = "l"
up_processes_table.align["run from"] = "l"
up_processes_table.align["features"] = "l"
down_processes_table = PrettyTable()
down_processes_table.field_names = ["name", "healthcheck"]
down_processes_table.align = "r"
down_processes_table.align["name"] = "l"
down_processes_table.sortby = "name"
all_processes = context.process_manager.all_processes()
for service in context.services():
responses = service.status(all_processes)
if responses:
for response in responses:
up_processes_table.add_row(_service_status_to_row(response))
elif show_down_services:
down_processes_table.add_row([service.service_name, b.bold + b.fail + "DOWN" + b.endc])
result = ["Running:", str(up_processes_table)]
if show_down_services:
result.append("Down:")
result.append(str(down_processes_table))
return result
def main():
init()
ser = serial.Serial(COM, 19200)
while True:
schr = ser.read()
char = c2ascii(schr)
chx = c2hex(schr)
if char == 'D':
getparam(ser, 'D', 'Haaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah')
getparam(ser, '_', 'hhhhahhhhhHhhhhh')
elif char == 'S':
getparam(ser, 'S', 'Hhhhh')
getparam(ser, '_', 'hhhhahhhhhHhhhhh')
elif char == 'R':
getparam(ser, 'R', 'hhhhh')
elif char == 'C':
getparam(ser, 'C', 'hhhhhhhhhh')
elif char == 'B':
getparam(ser, 'B', 'hhh')
#elif char == 'Z':
# getparam(ser, 'Z', 'h')
#elif char == 'W':
# getparam(ser, 'W', 'H')
elif char and ('A' <= char and char <= 'Z' or
'a' <= char and char <= 'z'):
printc(char, Fore.WHITE, prepend = ' ')
else:
printc(chx, Fore.YELLOW)
def Main(self):
t1 = datetime.datetime.now()
colorama.init()
opt_parser = self._GetOptParser()
options, dummy_args = opt_parser.parse_args()
logging.basicConfig(level=options.log_level)
# If no configurations are specified, run all configurations.
if not options.configs:
options.configs = ['Debug', 'Release']
result = 0
for config in set(options.configs):
# We don't catch any exceptions that may be raised as these indicate
# something has gone really wrong, and we want them to interrupt further
# tests.
if not self.Run(config, force=options.force):
_LOGGER.error('Configuration "%s" of test "%s" failed.',
config, self._name)
result = 1
# Now dump all error messages.
sys.stdout.write(self._GetStderr())
t2 = datetime.datetime.now()
_LOGGER.info('Unittests took %s to run.', t2 - t1)
return result
def main():
# Initialize color support
colorama.init()
try:
run()
except util.DeviceException as e:
typ, val, tb = sys.exc_info()
logging.debug("".join(traceback.format_exception(typ, val, tb)))
print(colorama.Fore.RED + "There is a problem with your device"
" configuration:")
print(colorama.Fore.RED + e.message)
except ConfigError as e:
typ, val, tb = sys.exc_info()
logging.debug("".join(traceback.format_exception(typ, val, tb)))
print(colorama.Fore.RED +
"There is a problem with your configuration file(s):")
print(colorama.Fore.RED + e.message)
except util.MissingDependencyException as e:
typ, val, tb = sys.exc_info()
logging.debug("".join(traceback.format_exception(typ, val, tb)))
print(colorama.Fore.RED +
"You are missing a dependency for one of your enabled plugins:")
print(colorama.Fore.RED + e.message)
except KeyboardInterrupt:
colorama.deinit()
sys.exit(1)
except Exception as e:
typ, val, tb = sys.exc_info()
print(colorama.Fore.RED + "spreads encountered an error:")
print(colorama.Fore.RED +
"".join(traceback.format_exception(typ, val, tb)))
# Deinitialize color support
colorama.deinit()
def runExecutable(exe, number, threads):
"""
Run <exe> <number> times, randomising the input parameters.
Each execution is independent so allow <exe> to be run over <threads> threads
@param: Executable to run
@param: Number of times to run <exe>
@param: Number of threads to concurrently use
@return: Nothing
"""
# We could read this from ../includes/inputs.h
MAX_Z = 118
# Set the minimum possible Z range
MAX_LOW_Z = MAX_Z - 1
colorama.init()
print("\nUsing: "
+ colorama.Fore.GREEN + exe + colorama.Style.RESET_ALL
+ " to create "
+ colorama.Fore.GREEN + str(number) + colorama.Style.RESET_ALL
+ " chart(s)\n")
colorama.deinit()
Parallel(threads)(delayed(createSingleChart)(MAX_LOW_Z, MAX_Z) for i in range(0, number))
print()
def main(args):
# Window terminals need some customization to work out-of-the-box with unicode.
if 'win32' in sys.platform:
# Must be a UTF-8 compatible codepage in the terminal or output doesn't work.
with open(os.devnull, 'w') as null:
subprocess.call(['chcp', '65001'], stdout=null, stderr=null, shell=True)
# Optionally relaunch the application to let Python update the stdout encoding.
try:
print("…\r \r", end='')
except UnicodeEncodeError:
return os.spawnv(os.P_WAIT, sys.executable, [sys.executable] + args)
# Use colored console output; required on Windows only, works by default elsewhere.
try:
import colorama; colorama.init(); del colorama
except ImportError:
pass
# Fail if the user is running from a system-wide Python 3.4 installation.
if not hasattr(sys, 'base_prefix'):
display('ERROR: Please run this script from a virtual environment.\n', color=ansi.RED_B)
executable = os.path.split(sys.executable)[1]
display(' > {} -m venv pyenv\n'.format(executable), color=ansi.RED)
return 1
app = Application()
return app.main(args[1:])
def main(argv=None):
"""
The entry point of the application.
"""
colorama.init()
usage = __doc__[__doc__.find('Usage:'):]
version = 'pytest-watch ' + __version__
argv = argv if argv is not None else sys.argv[1:]
args = docopt(usage, argv=argv, version=version)
pytest_args = []
directories = args['<directories>']
if '--' in directories:
index = directories.index('--')
pytest_args = directories[index + 1:]
directories = directories[:index]
ignore = (args['--ignore'] or '').split(',')
extensions = [('.' if not ext.startswith('.') else '') + ext
for ext in (args['--ext'] or '.py').split(',')]
return watch(directories=directories,
ignore=ignore,
auto_clear=args['--clear'],
beep_on_failure=not args['--nobeep'],
onpass=args['--onpass'],
onfail=args['--onfail'],
beforerun=args['--beforerun'],
poll=args['--poll'],
extensions=extensions,
args=pytest_args,
spool=not args['--no-spool'],
verbose=args['--verbose'],
quiet=args['--quiet'])
def printBoard(self, player, gettingDest=False, pieceRow=-1, pieceCol=-1, jumping=False):
init(autoreset=True)
padding = 2
print("Current board state:")
for i in range(len(self.square)):
printRow = ''
for j in range(len(self.square[i])):
printValue = ''
padding = 1
if i % 2 != j % 2:
printValue = printValue + Fore.BLACK #Remove unusable squares
if self.square[i][j].color != self.players[player].color and self.square[i][j].color != self.square[i][j].empty:
printValue = printValue + Style.BRIGHT + Fore.RED #Highlight opponent pieces
if self.square[i][j].color == self.players[player].color:
printValue = printValue + Style.DIM + Fore.GREEN #Color and dim all player pieces
if not gettingDest and self.hasValidMoves(i, j, player):
printValue = printValue + Style.BRIGHT #Highlight available player pieces
if gettingDest:
if pieceRow > -1 and pieceCol > -1 and pieceRow < len(self.square) and pieceCol < len(self.square[i]): #Valid square
if [i,j] in self.generateMoveList(pieceRow, pieceCol, jumping):
printValue = printValue + Style.BRIGHT + Fore.YELLOW #Highlight available destinations
if i == pieceRow and j == pieceCol:
printValue = printValue + Style.BRIGHT + Fore.GREEN #Highlight current piece [redundant, but available to be changed]
printValue = printValue + (2-len(str((i*len(self.square[i]))+j)))*' ' + str((i*len(self.square[i]))+j) + ' ' #Include Legend
if self.square[i][j].topDir in self.square[i][j].myDir and self.square[i][j].botDir in self.square[i][j].myDir:
printValue = printValue + str(self.square[i][j].color) #King Piece, double print
padding = 0
printValue = printValue + str(self.square[i][j].color) + Fore.RESET
printRow = printRow + Style.DIM + '[' + printValue + ' '*padding + Style.DIM + ']' + Style.RESET_ALL
print(printRow)
def get_device_manager():
global _device_manager
if _device_manager is None:
from . import core
try:
import _frida
except Exception as ex:
import colorama
from colorama import Back, Fore, Style
import sys
colorama.init(autoreset=True)
print("")
print("***")
if str(ex).startswith("No module named "):
print(Back.RED + Fore.WHITE + Style.BRIGHT + "Frida native extension not found")
print(Fore.WHITE + Style.BRIGHT + "Please check your PYTHONPATH.")
else:
print(Back.RED + Fore.WHITE + Style.BRIGHT + "Failed to load the Frida native extension: %s" % ex)
if sys.version_info[0] == 2:
current_python_version = "%d.%d" % sys.version_info[:2]
else:
current_python_version = "%d.x" % sys.version_info[0]
print(Fore.WHITE + Style.BRIGHT + "Please ensure that the extension was compiled for Python " + current_python_version + ".")
print("***")
print("")
raise ex
_device_manager = core.DeviceManager(_frida.DeviceManager())
_device_manager.enumerate_devices() # warm up
return _device_manager
def _handle_soft_error(exc_type, exc_value, exc_tb):
colorama.init()
err(Fore.LIGHTRED_EX + exc_type.__name__ + ": " + str(exc_value) + Style.RESET_ALL)
# Convert to the list of frames
tb = exc_tb
frames = []
while tb:
frames.append(tb.tb_frame)
tb = tb.tb_next
i0 = len(frames) - 1 - getattr(exc_value, "skip_frames", 0)
indent = " " * (len(exc_type.__name__) + 2)
for i in range(i0, 0, -1):
co = frames[i].f_code
func = _find_function_from_code(frames[i - 1], co)
fullname = _get_method_full_name(func) if func else "???." + co.co_name
highlight = getattr(exc_value, "var_name", None) if i == i0 else None
args_str = _get_args_str(func, highlight=highlight)
indent_len = len(exc_type.__name__) + len(fullname) + 6
line = Fore.LIGHTBLACK_EX + indent + ("in " if i == i0 else " ")
line += (Fore.CYAN + fullname + Fore.LIGHTBLACK_EX if i == i0 else fullname) + "("
line += _wrap(args_str + ") line %d" % frames[i].f_lineno, indent=indent_len)
line += Style.RESET_ALL
err(line)
err()
colorama.deinit()
def generateMoveList(self, row, col, needJump=False): init() if self.game == self.checkers: moveList = [] if self.square[row][col].topDir in self.square[row][col].myDir: #Top-style movement if not needJump: if col < len(self.square[row])-1 and row < len(self.square)-1: #Down-right moveList.append([row+1, col+1]) if col > 0 and row < len(self.square)-1: #Down-left moveList.append([row+1, col-1]) if row < len(self.square)-2 and col > 1: #Top-style jumping (left) if self.square[row+1][col-1].color not in [self.square[row][col].color, self.square[row][col].empty]: moveList.append([row+2, col-2]) if row < len(self.square)-2 and col < len(self.square[row])-2: #Top-style jumping (right) if self.square[row+1][col+1].color not in [self.square[row][col].color, self.square[row][col].empty]: moveList.append([row+2, col+2]) if self.square[row][col].botDir in self.square[row][col].myDir: #Bot-style movement if not needJump: if col < len(self.square[row])-1 and row > 0: #Up-right moveList.append([row-1, col+1]) if col > 0 and row > 0: #Up-left moveList.append([row-1, col-1]) if row > 1 and col > 1: #Bot-style jumping (left) if self.square[row-1][col-1].color not in [self.square[row][col].color, self.square[row][col].empty]: moveList.append([row-2, col-2]) if row > 1 and col < len(self.square[row])-2: #Bot-style jumping (right) if self.square[row-1][col+1].color not in [self.square[row][col].color, self.square[row][col].empty]: moveList.append([row-2, col+2]) validMoves = [] for i in moveList: #Is that square empty/on the board? if self.square[i[0]][i[1]].color == self.emptySpace: validMoves.append(i) return validMoves
def print_queue(sonos):
queue = sonos.get_queue()
ANSI_BOLD = '\033[1m'
ANSI_RESET = '\033[0m'
# colorama.init() takes over stdout/stderr to give cross-platform colors
if colorama:
colorama.init()
current = int(sonos.get_current_track_info()['playlist_position'])
queue_length = len(queue)
padding = len(str(queue_length))
for idx, track in enumerate(queue, 1):
if (idx == current):
color = ANSI_BOLD
else:
color = ANSI_RESET
idx = str(idx).rjust(padding)
print(
"%s%s: %s - %s. From album %s." % (
color,
idx,
track['artist'],
track['title'],
track['album']
)
)
# Release stdout/stderr from colorama
if colorama:
colorama.deinit()
def __enter__(self):
if readline_loaded:
if readline.__doc__ and 'libedit' in readline.__doc__:
readline.parse_and_bind("bind '\t' rl_complete") # Enable tab completions on MacOS
else:
readline.parse_and_bind("tab: complete") # and on other OSs
readline.parse_and_bind("set completion-ignore-case on")
readline.parse_and_bind("set show-all-if-ambiguous on")
readline.parse_and_bind("set completion-map-case on")
readline.parse_and_bind("set show-all-if-unmodified on")
readline.parse_and_bind("set expand-tilde on")
history_file_dir = appdirs.user_data_dir(self.this_program_name, self.this_program_name)
os.makedirs(history_file_dir, exist_ok=True)
self.history_file_path = os.path.join(history_file_dir, "." + self.this_program_name + "_console_history")
try:
readline.read_history_file(self.history_file_path)
except Exception: # Corrupt or non existent history file might raise an exception
try:
os.remove(self.history_file_path)
except Exception:
pass # if removing the file also fail - just ignore it
if colorama_loaded:
colorama.init()
self.prompt = self.this_program_name + ": "
self.save_dir = os.getcwd()
return self
def main():
arguments = docopt(__doc__, version=__version__)
quantity = int(arguments['--quantity'])
chain = MarkovChain(
min_length=int(arguments['--min']),
max_length=int(arguments['--max']),
)
if arguments['--json']:
output = {'quantity': quantity}
output['names'] = list(islice(chain.unique_word(), quantity))
print(json.dumps(output))
else:
init(autoreset=True)
for i, word in enumerate(chain.unique_word()):
if i == quantity:
break
line = '{:>3}. {:<12}'.format(i + 1, word)
if arguments['--nocolour']:
print(line)
else:
# alternate row colours
colour = Fore.BLUE if i % 2 == 0 else Fore.CYAN
print(Style.BRIGHT + colour + line)
def make_print():
if(args.color):
import colorama
colorama.init()
color_dict = {"default": "",
"header": colorama.Back.WHITE + colorama.Fore.BLACK,
"zebra_0": "",
"zebra_1": colorama.Style.BRIGHT,
"WARN": colorama.Fore.YELLOW,
"ERROR": colorama.Fore.RED}
def n_print(*args, **kwargs):
"""Print with colors"""
try:
c = color_dict[kwargs.pop("color")]
args = (c + str(args[0]),) + args[1:] + (colorama.Style.RESET_ALL,)
except KeyError as e:
pass
except IndexError as e:
pass
return __builtin__.print(*args, **kwargs)
else:
def n_print(*args, **kwargs):
if("color" in kwargs):
kwargs.pop('color')
return __builtin__.print(*args, **kwargs)
return n_print
def runtest(self):
if not ChefTestItem.__initialized_logging__:
colorama.init()
hdl = logging.StreamHandler(stream=sys.stdout)
logging.getLogger().addHandler(hdl)
logging.getLogger().setLevel(logging.INFO)
ChefTestItem.__initialized_logging__ = True
fs = self._prepareMockFs()
argv = self.spec['args']
if isinstance(argv, str):
argv = argv.split(' ')
expected_code = self.spec.get('code', 0)
expected_out = self.spec.get('out', '')
with mock_fs_scope(fs):
memstream = io.StringIO()
hdl = logging.StreamHandler(stream=memstream)
logging.getLogger().addHandler(hdl)
try:
from piecrust.main import PreParsedChefArgs, _run_chef
pre_args = PreParsedChefArgs(
root=fs.path('/kitchen'))
exit_code = _run_chef(pre_args, argv)
finally:
logging.getLogger().removeHandler(hdl)
assert expected_code == exit_code
assert expected_out == memstream.getvalue()
def main():
usage = """\
usage: hc [code] [options]
code may contain regular expression or use 'x' to denote any digit
code examples: 418, 30[12], 3.*, 1xx
Without parameters lists all available
HTTP status codes and their description
"""
parser = optparse.OptionParser(usage=textwrap.dedent(usage))
parser.add_option(
'-s', '--search', dest='search',
help=('Search for a code by name or description. '
'Search text may contain regular expressions.')
)
options, args = parser.parse_args()
# initialize colorama
init()
if options.search is not None:
_print_search(options.search)
elif args:
code = args[0]
if _IS_THREE_DIGIT_CODE(code):
_print_code(int(code))
else:
_print_filtered_codes(code)
else:
_print_codes()
def main(args, app_dir=None):
"""Main entry points.
Args:
args: command line arguments excluding executable name.
app_dir: directory with app.yaml, or None to autodiscover based on __file__.
"""
# Search for app.yaml in parent directory. If found, it means gae.py was
# symlinked to some GAE app directory. Such symlink allows to avoid typing
# --app-dir parameter all the time.
if app_dir is None:
script_dir = os.path.dirname(os.path.abspath(__file__))
app_yaml_path = gae_sdk_utils.find_app_yaml(script_dir)
if app_yaml_path:
app_dir = os.path.dirname(app_yaml_path)
colorama.init()
dispatcher = subcommand.CommandDispatcher(__name__)
try:
return dispatcher.execute(OptionParser(app_dir), args)
except gae_sdk_utils.LoginRequiredError:
print >>sys.stderr, "Login first using 'login' subcommand."
return 1
except KeyboardInterrupt:
# Don't dump stack traces on Ctrl+C, it's expected flow in some commands.
print >>sys.stderr, "\nInterrupted"
return 1
def main():
# Initialise colorama
init()
# Show title screen
title()
# Main game loop
while True:
# Check if the player's health is below zero and end the game
if player["health"] <= 0:
nice_print("You have died! Game over!", Fore.RED)
quit()
# Check if the player has met the victory condition and end the game
if item_fire in player["inventory"]:
nice_print_line("Your fire now burns brightly on the top of the cliffs")
nice_print_line("Any passing planes or ships are sure to see you on the island")
nice_print_line("But will anyone arrive in time, or is it already too late for you?")
nice_print_line("Only time will decide")
credits(1)
quit()
# Display game status (location description, inventory etc.)
print_location(player["current_location"])
if player["current_location"]["enemy"]:
combat(player["current_location"]["enemy"])
print_location(player["current_location"])
print_player(player)
print_inventory_items(player["inventory"])
# Show the menu with possible actions and ask the player
command = menu(player["current_location"]["exits"], player["current_location"]["items"], player["inventory"])
# Execute the player's command - repeat the options if the command cannot be performed
while not execute_command(command):
command = menu(player["current_location"]["exits"], player["current_location"]["items"], player["inventory"])
def main(args):
# gae.py may be symlinked into app's directory or its subdirectory (to avoid
# typing --app-dir all the time). If linked into subdirectory, discover root
# by locating app.yaml. It is used for Python GAE apps and one-module Go apps
# that have all YAMLs in app root dir.
app_dir = None
if IS_SYMLINKED:
script_dir = os.path.dirname(os.path.abspath(__file__))
app_dir = find_app_dir(script_dir)
# If not symlinked into an app directory, try to discover app root starting
# from cwd.
app_dir = app_dir or find_app_dir(os.getcwd())
colorama.init()
dispatcher = subcommand.CommandDispatcher(__name__)
try:
return dispatcher.execute(OptionParser(app_dir), args)
except gae_sdk_utils.BadEnvironmentConfig as e:
print >> sys.stderr, str(e)
return 1
except gae_sdk_utils.LoginRequiredError:
print >> sys.stderr, 'Login first using \'login\' subcommand.'
return 1
except KeyboardInterrupt:
# Don't dump stack traces on Ctrl+C, it's expected flow in some commands.
print >> sys.stderr, '\nInterrupted'
return 1
def init(self):
co.init()
self.logwrite("\n\n" + time.strftime("%c"))
self.lprint("Welcome to " + self.name + "!")
if os.geteuid():
self.print_err("You need to run this as root!")
sys.exit(1)
self.checkdep()
if not re.match("^/dev/((h|s)d[a-z]+|mmcblk[0-9]+)$", self.sdcard):
self.print_err("Wrong sdcard format! Should be in the form"
"/dev/[hdX|sdX|mmcblkX] eg. /dev/sda or"
"/dev/mmcblk0")
sys.exit(1)
if not os.path.exists(self.sdcard):
self.print_err("SD card path does not exist.")
sys.exit(1)
self.lprint(co.Fore.RED + "This is your last chance to abort!" +
co.Fore.RESET)
self.print_warn("Your sdcard is %s. Is that right? [yN] "
% self.sdcard)
if input().lower() not in ["y", "yes"]:
self.lprint("OK. Aborting ...")
sys.exit(0)
self.tmp = tm.mkdtemp()
def __init__(self, logdir, logfile, logformat=None, datefmt=None, logfilemode='w',
verbose=False, interactive=False):
init(autoreset=True)
self.logdir = logdir
self.logfile = logfile
self.interactive = interactive
self.verbose = verbose
self.interactive_format = '{level:<8s} {msg:<1s}'
if not os.path.exists(self.logdir):
os.makedirs(self.logdir)
if self.verbose:
self.level = logging.DEBUG
else:
self.level = logging.INFO
if logformat:
self.format = logformat
else:
self.format = '%(asctime)s %(levelname)-8s %(message)s'
if datefmt:
self.datefmt = datefmt
else:
self.datefmt = '%Y-%m-%d %H:%M:%S'
logging.basicConfig(level=self.level,
format=self.format,
datefmt=self.datefmt,
filename=os.path.join(self.logdir, self.logfile),
filemode=logfilemode)
def _get_color_printer(stream=sys.stdout, colors=True, rank=0):
"""
Return a print function tied to a particular stream, along with coloring info.
"""
try:
from colorama import init, Fore, Back, Style
init(autoreset=True)
except ImportError:
Fore = Back = Style = _NoColor()
if not colors:
Fore = Back = Style = _NoColor()
if MPI and MPI.COMM_WORLD.rank != rank:
if rank >= MPI.COMM_WORLD.size:
if MPI.COMM_WORLD.rank == 0:
print("Specified rank (%d) is outside of the valid range (0-%d)." %
(rank, MPI.COMM_WORLD.size - 1))
sys.exit()
def color_print(s, **kwargs):
pass
else:
def color_print(s, fore='', color='', end=''):
"""
"""
print(color + s, file=stream, end='')
print(Style.RESET_ALL, file=stream, end='')
print(end=end)
return color_print, Fore, Back, Style
def __init__(self, argv, root=False):
if root:
if getpass.getuser() != "root":
print "Must run as root"
exit(1)
self.argv = argv
self.optparser = OptionParser(version=RELEASE)
self.opt = None
self.args = None
common_opts = OptionGroup(
self.optparser, "Common options", "These options are common to all Globus Provision commands"
)
self.optparser.add_option_group(common_opts)
common_opts.add_option("-v", "--verbose", action="store_true", dest="verbose", help="Produce verbose output.")
common_opts.add_option(
"-d", "--debug", action="store_true", dest="debug", help="Write debugging information. Implies -v."
)
common_opts.add_option(
"-i",
"--instances-dir",
action="store",
type="string",
dest="dir",
default=defaults.INSTANCE_LOCATION,
help="Use this directory to store information about the instances "
"(instead of the default ~/.globusprovision/instances/)",
)
colorama.init(autoreset=True)
if not l:
continue
chunk = np.fromstring(data, dtype=np.int16)
dom = dominant(frame_rate, chunk)
if in_packet and match(dom, HANDSHAKE_END_HZ):
print("Received End hand shake")
byte_stream = extract_packet(packet)
try:
byte_stream = RSCodec(FEC_BYTES).decode(byte_stream)
display(str(byte_stream))
display("")
except ReedSolomonError as e:
print("{}: {}".format(e, byte_stream))
packet = []
in_packet = False
elif in_packet:
packet.append(dom)
elif match(dom, HANDSHAKE_START_HZ):
print("Received Start hand shake")
in_packet = True
if __name__ == '__main__':
colorama.init(strip=not sys.stdout.isatty())
#decode_file(sys.argv[1], float(sys.argv[2]))
listen_linux()
import xlrd
from colorama import init, Style, Fore
from getkey import getkey, keys
__version__ = "2019-7-18 version: 0.9"
IS_PY3 = sys.version_info > (3, 3)
IS_WIN = os.name == "nt"
# sys.stdout = io.TextIOWrapper(sys.stdout.buffer,encoding='utf-8')
if not IS_PY3:
reload(sys)
sys.setdefaultencoding("utf-8")
osp = os.path
init(autoreset=True)
def get_str_bytes(s):
# 从excel读取的内容（由于系统编码被设置为utf-8，所以内容为utf-8）
try:
return s.decode("utf-8")
except:
return s
def convert_to_utf8(s):
# 从系统读取的文件名,例如:路径名
try:
if IS_WIN:
return s.decode("gbk", "ignore")
else:
return s.decode("utf-8")
if (sys.version_info[0] != 2) or (sys.version_info[1] < 6):
exit("\nYou're running Python version {0}.{1}.{2}.\nW.R.E.C.K. requires Python version 2.6.x or 2.7.x to run!\n".format(*sys.version_info[0:3]))
sys.dont_write_bytecode = True
from time import time as gettime
from os import makedirs
from traceback import extract_tb
# Color support
if 'bw' in sys.argv:
COLORAMA = ('', '', '', '', '', '', '', '')
else:
try:
import colorama
colorama.init()
COLORAMA = ('\x1b[0m', '\x1b[31m', '\x1b[32m', '\x1b[33m', '\x1b[34m', '\x1b[35m', '\x1b[36m', '\x1b[37m')
except:
COLORAMA = ('', '', '', '', '', '', '', '')
from compiler import *
write_id_files = "ID_%s.py" # Where the compiler will write new iteration ID-files.
show_performance_data = False # Set to true to display compiler performance data by default.
export_filename = '%s.txt' # How to name export files (only used for some debugging purposes).
WRECK.time_started = gettime()
import re
import typing
import warnings
from collections import defaultdict
from dataclasses import dataclass, field, fields
from statistics import median
from threading import Lock, RLock, Thread
from typing import List
import colorama
from colorama import Back, Fore, Style
from . import helpers
from .locks import SLock
colorama.init(autoreset=True)
COLORS = {
"CRITICAL": Fore.RED,
"WARNING": Fore.RED,
"CAUTION": Fore.YELLOW,
"IMPORTANT": Fore.CYAN,
"GOOD": Fore.GREEN,
}
def getDimentions() -> typing.Tuple[int]:
return (int(x) for x in os.popen("stty size", "r").read().split())
def getRows() -> int:
from dateClass import Date
from plateClass import Plate
from timeClass import Time
import datetime
from constantsClass import Constants
from colorama import Back, Fore, init, Style
init()
if __name__ == "__main__":
print(
Fore.BLUE +
"Welcome, insert plate, time and date to consult if you are under restriction to circulate\n"
+ Style.RESET_ALL)
"""
Receiving plate, input and date of user's vehicle
For all of them, checking whether the info is in the right format
"""
while True:
plateInput = input(
"Please, insert the plate number of your vehicle: ").upper()
if not Constants.PLATEPATTERN.match(plateInput):
print("Sorry, the correct format is: AAA111 or AAA1111")
continue
else:
plate = Plate(plateInput)
break
while True:
dateInput = input(
"Please, insert the date (dd-mm-yyyy) you want to consult: ")
try:
from lib.parser_html import Parsing
from lib.request import Browser
from colorama import Fore
import argparse
import colorama
import time
import os
colorama.init(True)
class Unactive:
def __init__(self, ses=None) -> None:
self._params = {}
self.__ses = ses
def login(self, session):
data = Parsing(session.get('profile.php').text)
if "mbasic_logout_button" in str(data.to_bs4):
friends = data.find_url('friends?lst')
self._params.update({'friends': friends})
self.__ses = session
return True
def unfriend(self, user):
link_unfriend = Parsing(self.__ses.get(
user["url"]).content).find_url('removefriend')
form = Parsing(self.__ses.get(
link_unfriend).content).parsing_form('remove')
action = form["action"]
import threading
import requests
except:
subprocess.check_call(
[sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
try:
import twint
except ImportError:
subprocess.check_call([
sys.executable, "-m", "pip", "install", "--user", "--upgrade",
"git+https://github.com/twintproject/twint.git@origin/master#egg=twint"
])
import twint
init(convert=True)
# Config class for retrieving Binance credentials from .toml file
class Config:
def __init__(self):
self.config = toml.load('data/config.toml')
if self.config["binance"]:
binance = self.config["binance"]
self.api_key = binance["api_key"]
self.secret_key = binance["secret_key"]
def get_toml(self):
self.config = toml.load('data/config.toml')
binance = self.config["binance"]
self.api_key = binance["api_key"]
"label": "Discord Server",
"url": "https://discord.gg/k48Ht5y"
},
],
)
debugOutput("Rich presence updated")
except: # Discord not launched
if debug == "y":
raise
time.sleep(15) # 15 seconds to respect Discord rate limit
if __name__ == "__main__":
multiprocessing.freeze_support()
cpu = cpuinfo.get_cpu_info() # Processor info
init(autoreset=True) # Enable colorama
title(getString("duco_python_miner") + str(minerVersion) + ")")
try:
loadConfig() # Load config file or create new one
debugOutput("Config file loaded")
except:
print(now().strftime(Style.DIM + "%H:%M:%S ") + Style.RESET_ALL +
Style.BRIGHT + Back.GREEN + Fore.WHITE + " sys0 " +
Style.RESET_ALL + Style.BRIGHT + Fore.RED +
getString("load_config_error") + resourcesFolder +
getString("load_config_error_warning") + Style.RESET_ALL)
if debug == "y":
raise
time.sleep(10)
os._exit(1)
def main():
colorama.init()
parser = argparse.ArgumentParser(epilog="supported data file formats:\n" +
DataParser.format_parsers(),
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('filename',
type=str,
nargs='+',
help="filename of data file")
parser.add_argument('-v',
'--version',
action='version',
version='%s v%s' % (parser.prog, __version__))
parser.add_argument('-d',
'--debug',
action='store_true',
help="enable debug logging")
parser.add_argument('-uc',
'--unconfirmed',
action='store_true',
help="include unconfirmed transactions")
parser.add_argument('-ca',
dest="cryptoasset",
type=str,
help="specify a cryptoasset symbol, if it cannot be identified "
"automatically")
parser.add_argument('--duplicates',
action='store_true',
help="remove any duplicate input rows across data files")
parser.add_argument('--format',
choices=[config.FORMAT_EXCEL, config.FORMAT_CSV, config.FORMAT_RECAP],
default=config.FORMAT_EXCEL,
type=str.upper,
help="specify the output format, default: EXCEL")
parser.add_argument('-nh',
'--noheader',
action='store_true',
help="exclude header from CSV output")
parser.add_argument('-a',
'--append',
action='store_true',
help="append original data as extra columns in the CSV output")
parser.add_argument('-s',
'--sort',
action='store_true',
help="sort CSV output by timestamp")
parser.add_argument('-o',
dest='output_filename',
type=str,
help="specify the output filename")
args = parser.parse_args()
config.debug = args.debug
DataFile.remove_duplicates = args.duplicates
if config.debug:
sys.stderr.write("%s%s v%s\n" % (Fore.YELLOW, parser.prog, __version__))
sys.stderr.write("%spython: v%s\n" % (Fore.GREEN, platform.python_version()))
sys.stderr.write("%ssystem: %s, release: %s\n" % (
Fore.GREEN, platform.system(), platform.release()))
for filename in args.filename:
pathnames = glob.glob(filename)
if not pathnames:
pathnames = [filename]
for pathname in pathnames:
try:
do_read_file(pathname, args)
except UnknownCryptoassetError as e:
sys.stderr.write(Fore.RESET)
parser.error("%s, please specify using the [-ca CRYPTOASSET] option" % e)
except UnknownUsernameError as e:
sys.stderr.write(Fore.RESET)
parser.exit("%s: error: %s, please specify usernames in the %s file" % (
parser.prog, e, config.BITTYTAX_CONFIG))
except DataFilenameError as e:
sys.stderr.write(Fore.RESET)
parser.exit("%s: error: %s" % (parser.prog, e))
except DataFormatUnrecognised as e:
sys.stderr.write("%sWARNING%s %s\n" % (
Back.YELLOW+Fore.BLACK, Back.RESET+Fore.YELLOW, e))
except IOError as e:
if e.errno == errno.ENOENT:
sys.stderr.write("%sWARNING%s File does not exist: %s\n" % (
Back.YELLOW+Fore.BLACK, Back.RESET+Fore.YELLOW, pathname))
elif e.errno == errno.EISDIR:
sys.stderr.write("%sWARNING%s File is a directory: %s\n" % (
Back.YELLOW+Fore.BLACK, Back.RESET+Fore.YELLOW, pathname))
else:
sys.stderr.write("%sWARNING%s File could not be read: %s\n" % (
Back.YELLOW+Fore.BLACK, Back.RESET+Fore.YELLOW, pathname))
if DataFile.data_files:
if args.format == config.FORMAT_EXCEL:
output = OutputExcel(parser.prog, DataFile.data_files_ordered, args)
output.write_excel()
else:
output = OutputCsv(DataFile.data_files_ordered, args)
sys.stderr.write(Fore.RESET)
sys.stderr.flush()
output.write_csv()
import inspect
from itertools import groupby
from sys import _getframe
from colorama import init
from .constants import ATTR_MAP, CLASS, DEFAULT_CATEGORY, FUNCTION
from .format import format_category
init() # To support Windows.
class PrettyDir(object):
"""Class that provides pretty dir and search API."""
def __init__(self, obj=None):
self.obj = obj
self.attrs = []
if obj is None:
source = _getframe(1).f_locals
else:
source = {name: self.__getattr(name) for name in dir(obj)}
self.__inspect_category(source)
def __repr__(self):
output = []
for category, attrs in groupby(self.attrs, lambda x: x.category):
output.append(format_category(category, attrs))
output.sort(key=lambda x: x[0])
return '\n'.join(category_output[1] for category_output in output)
#This code was written by Kalen Willits
import os #Uses the operating system's clear screen funtion to refresh the terminal
import time #Allows the use of time.sleep funtion to delay a refresh
import keyboard #Listens to keyboard events -> Also can generate keyboard events
from colorama import init, deinit, Fore, Back, Style #Allows the use of different colors
init() #Initializes colorama, this is only required for windows OS.
print(Fore.BLACK + Back.BLACK
) #Sets the default color to all black. This hides keyboard inputs
import cursor
cursor.hide() #hides the blinking cursor
##################################Variable Library##############################
menu = ['Option Zero', 'Option One', 'Option Two', 'Exit']
################################################################################
def navigate(idx):
key = keyboard.read_key()
key = keyboard.read_key()
if key == 'up':
idx -= 1
if key == 'down':
idx += 1
if key == 'enter':
page_fuction(idx)
return idx #listens to keyboard inputs and changes the index(idx).
from bs4 import BeautifulSoup
import requests
import lxml
import replit
import colorama as cr
replit.clear()
cr.init(autoreset=True)
SubReddit = input(
"Which subreddit would you like to see popular posts for? r/").lower()
print("wait for the posts to load...")
url = ('https://www.reddit.com/r/' + SubReddit + '/top/?t=all')
headers = {
'User-Agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_2) AppleWebKit/601.3.9 (KHTML, like Gecko) Version/9.0.2 Safari/601.3.9'
}
response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.content, 'lxml')
Title = soup.title
print(url)
print('')
print('')
print(f"{cr.Fore.GREEN}there are no ads on this version of reddit!")
def main():
# Colorama module's initialization.
init(autoreset=True)
version_string = f"%(prog)s {__version__}\n" + \
f"{requests.__description__}: {requests.__version__}\n" + \
f"Python: {platform.python_version()}"
parser = ArgumentParser(
formatter_class=RawDescriptionHelpFormatter,
description=f"{module_name} (Version {__version__})")
parser.add_argument("--version",
action="version",
version=version_string,
help="Display version information and dependencies.")
parser.add_argument("--verbose",
"-v",
"-d",
"--debug",
action="store_true",
dest="verbose",
default=False,
help="Display extra debugging information.")
parser.add_argument("--quiet",
"-q",
action="store_false",
dest="verbose",
help="Disable debugging information (Default Option).")
parser.add_argument(
"--tor",
"-t",
action="store_true",
dest="tor",
default=False,
help=
"Make requests over TOR; increases runtime; requires TOR to be installed and in system path."
)
parser.add_argument(
"--unique-tor",
"-u",
action="store_true",
dest="unique_tor",
default=False,
help=
"Make requests over TOR with new TOR circuit after each request; increases runtime; requires TOR to be installed and in system path."
)
args = parser.parse_args()
# Load the data
data_file_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"data.json")
with open(data_file_path, "r", encoding="utf-8") as raw:
site_data_all = json.load(raw)
#Setup logging to show informational messages.
logging.basicConfig()
logging.getLogger().setLevel(logging.INFO)
result_summary = []
site_data = {
site: site_data_all[site]
for site in ['Twitter', 'eBay'] if site in site_data_all
}
result_summary.append(
sherlock_test(['hoadlck'], ['hoadlckblah'], site_data, args.verbose,
args.tor, args.unique_tor))
if all(result_summary):
logging.info(f"All tests succeeded!")
else:
logging.error(f"One of more tests failed!")
return
return "%s%s%s" % (colorama.Fore.WHITE, text, colorama.Style.RESET_ALL)
def blue(text):
return "%s%s%s" % (colorama.Fore.BLUE, text, colorama.Style.RESET_ALL)
def red(text):
return "%s%s%s" % (colorama.Fore.RED, text, colorama.Style.RESET_ALL)
def green(text):
return "%s%s%s" % (colorama.Fore.GREEN, text, colorama.Style.RESET_ALL)
def yellow(text):
return "%s%s%s" % (colorama.Fore.YELLOW, text,
colorama.Style.RESET_ALL)
sys.platform == "win32" and colorama.init()
except ImportError:
def bright(text):
return text
def dim(text):
return text
def white(text):
return text
def blue(text):
return text
def red(text):
import gym
from gym.envs.registration import register
from colorama import init
from kbhit import KBHit
init(autoreset=True) # Reset the terminal mode to display ansi color
register(id='FrozenLake-v3',
entry_point='gym.envs.toy_text:FrozenLakeEnv',
kwargs={
'map_name': '4x4',
'is_slippery': False
})
env = gym.make('FrozenLake-v3')
env.render()
key = KBHit()
while True:
action = key.getarrow()
if action not in [0, 1, 2, 3]:
print("Game aborted!")
break
state, reward, done, info = env.step(action)
env.render()
print("State: ", state, "Action: ", action, "Reward: ", reward, "Info: ",
info)
def __init__(self):
# `autoreset` allows us to not have to sent reset sequences for every
# string. `strip` lets us preserve color when redirecting.
colorama.init(autoreset=True, strip=False)
try:
_unicode = unicode
except NameError:
_unicode = str
try:
if IS_WIN:
import colorama
else:
raise ImportError
except ImportError:
colorama = None
else:
try:
colorama.init(strip=False)
except TypeError:
colorama.init()
try:
from weakref import WeakSet
except ImportError:
WeakSet = set
try:
_basestring = basestring
except NameError:
_basestring = str
try: # py>=2.7,>=3.1
from collections import OrderedDict as _OrderedDict
def run_pattern2(sql_sentence):
colorama.init()
result = parse_sql(sql_sentence)
if result[0] == 1:
print(Fore.BLUE + sql_sentence[:result[1]], end='')
print(Fore.WHITE + sql_sentence[result[1]:])
elif result[0] == 2:
# {keywords: [], runstreams: [], runningstream: []}
# 运行的数据流绿色, 关键字黄色, 正在运行的数据流
# 红色
keywords = result[1]["keywords"]
runstreams = result[1]["runstreams"]
runningstreams = result[1]["runningstreams"]
for i in range(len(sql_sentence)):
yellow = False
for keyword in keywords:
if keyword[0] <= i <= keyword[1]:
yellow = True
break
green = False
for runstream in runstreams:
if runstream[0] <= i <= runstream[1]:
green = True
break
red = False
for runningstream in runningstreams:
if runningstream[0] <= i <= runningstream[1]:
red = True
break
if yellow:
print(Fore.YELLOW + sql_sentence[i], end='')
elif green:
print(Fore.GREEN + sql_sentence[i], end='')
elif red:
print(Fore.RED + sql_sentence[i], end='')
else:
print(Fore.WHITE + sql_sentence[i], end='')
print()
elif result[0] == 3:
data = result[1]
list_maxchar = []
for i in range(len(data[0])):
list_maxchar.append(10)
for i in range(len(data)):
each_line = data[i]
for j in range(len(each_line)):
content = str(data[i][j])
_len = 0
for ch in content:
if '\u4e00' <= ch <= '\u9fff':
_len += 2
else:
_len += 1
if _len > list_maxchar[j]:
list_maxchar[j] = (int((_len - 1) / 10) + 1) * 10
# 打印最后结果
for i in range(len(data)):
each_line = data[i]
for j in range(len(each_line)):
content = str(data[i][j])
_len = 0
for ch in content:
if '\u4e00' <= ch <= '\u9fff':
_len += 1
content_print = content.rjust(list_maxchar[j] - _len, ' ')
print(content_print, end='|')
print()
__version__ = qsharp.version.version
except ImportError:
__version__ = "<unknown>"
# CLR Imports #
import clr
import System.Threading.Tasks
import Microsoft.Quantum.Simulation.Simulators as mqss
# External Python Imports #
try:
import colorama as ca
ca.init()
SIMULATOR_COLOR = ca.Fore.BLUE + ca.Back.WHITE
RESET_COLOR = ca.Style.RESET_ALL
except:
ca = None
SIMULATOR_COLOR = ""
RESET_COLOR = ""
try:
import qutip as qt
except:
qt = None
try:
from IPython.display import display
# Communicating with Benchtop YOKOGAWA dc-power supply
# Communicating with Benchtop PSG
from colorama import init, Fore, Back
init(autoreset=True) #to convert termcolor to wins color
from os.path import basename as bs
mdlname = bs(__file__).split('.')[
0] # model's name e.g. ESG, PSG, AWG, VSA, ADC
debugger = 'debug' + mdlname
import visa
from functools import wraps
from time import sleep, time
from contextlib import suppress
from pyqum.instrument.logger import address, set_status, status_code
from pyqum.instrument.toolbox import waveform
def debug(state=False):
exec('%s %s; %s = %s' % ('global', debugger, debugger, 'state'), globals(),
locals()) # open global and local both-ways channels!
if state:
print(Back.RED + '%s: Debugging Mode' % debugger.replace('debug', ''))
return
debug() # declare the debugger mode here
def run_cash_show_assistant(
nom_jeu, num_quest
): #num_quest pour ouvrir onglet avec la recherche de la question ouverte pour la dernière question de QUIDOL
f_debug = 2 #activation du log 0/1/2 => 2 Détaillé avec horodatages
#Fonction de récupération de la fenêtre
def _get_windows_bytitle(title_text, exact=True):
def _window_callback(hwnd, all_windows):
all_windows.append((hwnd, win32gui.GetWindowText(hwnd)))
windows = []
win32gui.EnumWindows(_window_callback, windows)
if exact:
return [hwnd for hwnd, title in windows if title_text == title]
else:
return [hwnd for hwnd, title in windows if title_text in title]
#Fonction de screenshot de la fenêtre complète
def screenshot(hwnd=None):
if not hwnd:
hwnd = win32gui.GetDesktopWindow()
l, t, r, b = win32gui.GetWindowRect(hwnd)
win32gui.SetForegroundWindow(hwnd)
sleep(0.1) #lame way to allow screen to draw before taking shot
return grab_part(l, t, r, b)
#Fonction de grab V2
def grab_part(left, top, right, bottom):
width = right - left
height = bottom - top
with mss.mss() as sct:
# The screen part to capture
monitor = {
'top': top,
'left': left,
'width': width,
'height': height
}
# Grab the data
sct_img = sct.grab(monitor)
# Create an Image
img = ImageScreen.frombytes('RGB', sct_img.size, sct_img.bgra,
'raw', 'BGRX')
#img.show() #debug pour afficher l'image découpée
img.save('ecranfull.png')
return img
def crop_zones(image, coord):
left, top, right, bottom = coord.replace(" ", "").split(",")
box = (int(left), int(top), int(right), int(bottom))
im = image.crop(box)
#zone.show()
return im
#Fonction de preprocessing de l'image
def pre_process_image(img):
img = img.convert('L')
enhancer = ImageEnhance.Contrast(img)
img = enhancer.enhance(2)
if nom_jeu == 'FLASHBREAK':
enhancer = ImageEnhance.Sharpness(img)
img = enhancer.enhance(2.5)
img = img.resize(tuple([3 * x for x in img.size]),
ImageScreen.LANCZOS) #LANCZOS ou ANTIALIAS
else:
enhancer = ImageEnhance.Sharpness(img)
img = enhancer.enhance(2.5)
img = img.resize(tuple([3 * x for x in img.size]),
ImageScreen.LANCZOS) #LANCZOS ou ANTIALIAS
enhancer = ImageEnhance.Sharpness(img)
img = enhancer.enhance(2)
#img.show() #debug pour afficher l'image après traitement
return img
#Fonction de lecture OCR
def convert_image_to_text(img, file):
img.save(file +
".png") #debug pour afficher l'image avant traitement OCR
if langue == 'german':
text = pytesseract.image_to_string(ImageScreen.open(file + ".png"),
config='--psm 6 -l deu')
else:
text = pytesseract.image_to_string(ImageScreen.open(file + ".png"),
config='--psm 6 -l fra+eng')
text = text.replace("\n", " ")
return text
def trt_img(indice):
csAnswer[indice] = pre_process_image(
crop_zones(image, str(coord[indice])))
temp = convert_image_to_text(csAnswer[indice],
"r" + str(indice)).strip().lower()
if langue != 'german':
if indice == 0:
temp = unidecode(temp.split("?", 1)[0])
else:
temp = unidecode(temp)
temp = re.sub(r'[^\w\s]', ' ', temp)
answer[indice] = temp
#Fonction du suppression des caractères superflus
def clean_html(html):
# Change HTML to punctuation encoding to actul punctuation
html = h.unescape(html)
html = clean_me(html)
# Get rid of HTML tags in HTML output
cleanr = re.compile('<.*?>')
html = re.sub(cleanr, '', html)
html = re.sub(r'[^\w\s]', '', html)
return html
#Fonction de netoyage des informations reçues
def clean_me(html):
soup = Soup(
html,
"html.parser") # create a new bs4 object from the html data loaded
for script in soup(["script", "style"
]): # remove all javascript and stylesheet code
script.extract()
# get text
text = soup.get_text()
# break into lines and remove leading and trailing space on each
lines = (line.strip() for line in text.splitlines())
# break multi-headlines into a line each
chunks = (phrase.strip() for line in lines
for phrase in line.split(" "))
# drop blank lines
text = '\n'.join(chunk for chunk in chunks if chunk)
return text
#Fonction de comptage des réponses dans le flux reçu
def hash_count(html_str, answer):
#filter out stop words in answers
stop_words = stopwords.words(langue)
counter = 0
answer_arr = answer.split()
answer_arr = [w for w in answer_arr if not w in stop_words]
for word in answer_arr:
if len(word) == 1 and len(
answer_arr
) == 1: #La réponse ne contient qu'un caractère, on recherche le caractère seul
counter = counter + html_str.count(
" " + word + " ") #pour ne pas compter les fins de mots
counter = counter + html_str.count(
"\n" + word + " "
) #pour prendre en compte les débuts de lignes de la recherche HTML
else:
if len(
word
) != 1: #La réponse contient plusieurs mots, on ne recherche pas les caractères seuls
counter = counter + html_str.count(
" " + word) #pour ne pas compter les fins de mots
counter = counter + html_str.count(
"\n" + word
) #pour prendre en compte les débuts de lignes de la recherche HTML
if len(word) > 3 and word[
0] == 'l': #cas d'une lecture erronée de l'apostrophe, on exclue le L de debut de la recherche
if word[0:2] == "l'":
counter = counter + html_str.count(word[2:])
else:
counter = counter + html_str.count(word[1:])
return counter
#Fonction de recherche de négation
def is_negative():
if langue == 'french':
#list_neg=["pas","est+pas","a+pas","a+jamais","existe+pas","sera+pas","on+pas","il+pas"]
list_neg = ["+pas", "jamais", "aucun"]
if langue == 'english':
list_neg = ["+not", "never", "none"]
if langue == 'german':
list_neg = ["kein", "keine", "nicht", "niemals", "+nie"]
for i in list_neg:
if answer[0].lower().find(i + '+') != -1:
print("NEGATION DETECTEE AVEC '" + i + "' - A CONFIRMER")
add_log("NEGATION DETECTEE AVEC '" + i + "' - A CONFIRMER\n",
1)
return True
return False #pas de negation definie pour cette langue
def is_which():
#return False #Comme ça ne marche pas terrible pour le moment, on désactive hors tests
if langue == 'french':
list_which = [
"lequel", "laquelle", "lesquels", "lesquelles", "aucun"
]
if langue == 'english':
list_which = ["which"]
if langue == 'german':
list_which = ["welche"]
for i in list_which:
if answer[0].lower().find(i) != -1:
return True
return False #pas de negation definie pour cette langue
#Fonction de log. Verbosité 1 = court, 2 = plus détaillé (si f_debug=2)
def add_log(mess, verb):
if f_debug > 0:
if verb == 1 or (verb == 2 and f_debug == 2):
text_file.write(mess)
#if verb == 2 and f_debug == 2 :
# text_file.write(mess)
#Fonction de lecture des coordonnées des Q/R
def lect_info_jeu():
#lecture des coordonnées
for ind in list_full:
csAnswer.append(" ")
answer.append(" ")
if ind == 0: #c'est la question
box = cfg.get(nom_jeu, 'quest')
else:
box = cfg.get(nom_jeu, 'r' + str(ind))
coord.append(box)
"""def lect_ini_liste_jeux():
cfg = ConfigParser.ConfigParser()
cfg.read('param_games.ini')
fenetre = Tk() #fenetre
# liste des jeux
liste = Listbox(fenetre)
mylist = [1,2,3,4,5,6,7,8,9]
for ind in mylist:
try:
jeu = cfg.get('JEUX', 'jeu'+str(ind))
jeu_lib = cfg.get(jeu,'libelle')
liste.insert(ind, str(ind)+' - '+jeu_lib)
except:
break;
print(jeu_lib)
liste.pack()
fenetre.mainloop()
print(liste.curselection())"""
#Début effectif du programme
reload(sys)
sys.setdefaultencoding("UTF-8")
if nom_jeu == 'bidon': #bidouille pour permettre le lancement de cashAssistant en solo sans passer par le menu
#nom_jeu = 'CS_FR'
#nom_jeu = 'FLASHBREAK'
#nom_jeu = 'QUIDOL'
#nom_jeu = 'WLQ'
#nom_jeu = 'CCL'
#nom_jeu = 'HQ'
#nom_jeu = 'CS_DE'
nom_jeu = 'CS_EN' #Cash Show Anglophones (US/UK/AU)
#Ouverture du fichier de log (au moins pour les debut/fin)
if f_debug >= 1:
text_file = open("Output" + nom_jeu + ".txt", "a")
add_log("\n==== lancement " + str(datetime.now()) + " ====\n", 1) #log
coord = [] #Cette liste contiendra les coordonnées des différentes Q/R
csAnswer = [] #Liste des images des réponses
answer = [] #Liste des textes des réponses (après passage OCR)
count = [] #Liste des scores
rep_exact = [] #Liste de nombre de réponses exactes
init(autoreset=True)
#Ouverture et lecture du fichier de paramétrage
cfg = ConfigParser.ConfigParser()
cfg.read('param_gamesv2.ini')
nb_rep = int(cfg.get(nom_jeu, 'nb_rep'))
langue = cfg.get(nom_jeu, 'langue')
list_full = range(0, nb_rep + 1) #liste avec la question en arg 0
list_rep = range(1, nb_rep + 1) #liste de réponses seulement
print("Jeu en Cours : " + cfg.get(nom_jeu, 'libelle'))
lect_info_jeu()
#Screenshots
start_time = time()
add_log("===== debut screenshot " + str(datetime.now()) + " ====\n",
2) #log
window_handle = _get_windows_bytitle("ApowerMirror")[0]
image = screenshot(window_handle)
add_log("===== fin screenshot " + str(datetime.now()) + " ====\n", 2) #log
#Traitement des Q/R (decoupage+preprocess+lecture OCR)
add_log("===== debut traitment Q/R " + str(datetime.now()) + " ====\n",
2) #log
NUM_WORKERS = nb_rep + 1
with concurrent.futures.ThreadPoolExecutor(
max_workers=NUM_WORKERS) as executor:
futures = {executor.submit(trt_img, ind) for ind in range(NUM_WORKERS)}
concurrent.futures.wait(futures)
"""with closing(multiprocessing.Pool(processes=NUM_WORKERS)) as pool:
pool.map_async(trt_img, list_full)
#results.wait()"""
for ind in list_full:
if ind == 0:
entete = 'Q : '
else:
entete = 'R' + str(ind) + ': '
print(entete + answer[ind])
if f_debug >= 1:
add_log(entete + answer[ind] + "\n", 1) #log
end_time = time()
print("Duree grab + OCR concurrent : %ssecs" % (end_time - start_time))
add_log("===== fin traitment Q/R " + str(datetime.now()) + " ====\n",
2) #log
#exit() #pour ne pas faire la recherche web
# -------------- Testing -----------------
"""
question = "Which of these US states does NOT contain a town called Springfield"
answer[1] = "montana"
answer[2] = "maine"
answer[3] = "michigan"
#answer[4] = "don camillo contre peppone"
"""
# ---------------------------------------
#Gérer les STOPWORDS sur la question pour simplifier la rechercher ?
# Write to logfile to see HTML
#add_log(question+"\n",2) #log
start_time2 = time()
answer[0] = answer[0].replace("&", "%26")
if is_which(): #Question du type "Lequel"
print("question lequel")
add_log("question lequel", 1)
stop_words = stopwords.words(langue)
quest_arr = answer[0].split()
quest_arr = [w for w in quest_arr if not w in stop_words]
quest_light = '+'.join(quest_arr)
answer[0] = answer[0].replace(" ", "+")
#for ind in list_rep:
# responseFromQuestion = get("https://google.com/search?q=" + question + "&num=30")
# Count instances of answer and lower-case answer
count.append(
int(0)) #enregistrement vide pour ne pas utiliser l'index 0
rep_exact.append(int(0))
total = 0
for ind in list_rep:
responseFromQuestion = get("https://google.com/search?q=" +
quest_light + " " + answer[ind] +
"&num=5")
h = HTMLParser()
html = responseFromQuestion.text.lower()
html = clean_html(html)
count.append(hash_count(
html,
answer[ind])) #Si réponse exacte trouvée, on la met en avant !
if count[ind] > 2000: #Si un gros score lors du hash_count, peut être un problème de recherche (réponse composée de plusieurs mots)
count[ind] = 0
rep_exact.append(html.count(answer[ind]))
count[ind] = count[ind] + rep_exact[ind]
total = total + count[ind] #comptage total
else: #question classique
answer[0] = answer[0].replace(" ", "+")
#webbrowser.open("https://google.com/search?q=" + question,new=1)
responseFromQuestion = get("https://google.com/search?q=" + answer[0] +
"&num=25")
h = HTMLParser()
html = responseFromQuestion.text.lower()
html = clean_html(html)
#add_log("\n\n\n"+html+"\n\n\n",2) #log
# Count instances of answer and lower-case answer
count.append(
int(0)) #enregistrement vide pour ne pas utiliser l'index 0
rep_exact.append(int(0))
total = 0
for ind in list_rep:
count.append(hash_count(
html,
answer[ind])) #Si réponse exacte trouvée, on la met en avant !
if count[ind] > 2000: #Si un gros score lors du hash_count, peut être un problème de recherche (réponse composée de plusieurs mots)
count[ind] = 0
rep_exact.append(html.count(answer[ind]))
count[ind] = count[ind] + rep_exact[ind]
total = total + count[ind] #comptage total
#Affichage des scores des différentes réponses
print("=============================")
for ind in list_rep:
if rep_exact[ind] == 0:
print("Score pour R" + str(ind) + " : " + str(count[ind]))
else:
print("Score pour R" + str(ind) + " : " + str(count[ind]) +
" dont " + str(rep_exact[ind]) + " rep EXACTE(S) trouvee(s)")
print(
"ATTENTION SI QUESTION AVEC NEGATION PRIVILEGIER LE SCORE LE PLUS BAS OU A ZERO"
)
print("=============================")
if f_debug >= 1:
for ind in list_rep:
if rep_exact[ind] == 0:
add_log("Score pour R" + str(ind) + " : " + str(count[ind]) +
"\n", 1) #log
else:
add_log("Score pour R" + str(ind) + " : " + str(count[ind]) +
" dont " + str(rep_exact[ind]) +
" rep EXACTE(S) trouvee(s)\n", 1) #log
#Affichage de la meilleure réponse
if total == 0:
print("Il n'y a aucune reponse trouvee. Probleme de lecture Q/R ?")
add_log("Il n'y a aucune réponse trouvée. Problème de lecture Q/R ? " +
str(datetime.now()) + " ====\n", 1) #log
else:
del count[
0] #suppression de l'index 0 le temps de récupérer le meilleur score
minCount = min(count)
maxCount = max(count)
count.insert(0, 0) #on remet l'index 0
del rep_exact[
0] #suppression de l'index 0 le temps de récupérer le meilleur score exacte
minCount_exact = min(rep_exact)
maxCount_exact = max(rep_exact)
rep_exact.insert(0, 0) #on remet l'index 0
#Test d'une négation
if is_negative():
for ind in list_rep:
if minCount_exact == rep_exact[ind] and minCount == count[
ind] and maxCount_exact >= 0: #Minimum exact ET Minimum hash c est la bonne réponse
print(
colored(
"La reponse est : " + str(ind) + " - " +
answer[ind], 'green'))
add_log("La reponse est : " + str(ind) + " - " +
answer[ind] + "\n", 1) #log
else:
if minCount_exact == rep_exact[ind]: #Minimum exact
print(
colored(
"La reponse est : " + str(ind) + " - " +
answer[ind], 'yellow'))
add_log("La reponse est : " + str(ind) + " - " +
answer[ind] + "\n", 1) #log
else:
if minCount == count[ind]: #Minimum hash
print(
colored(
"La reponse est : " + str(ind) + " - " +
answer[ind], 'red'))
add_log("La reponse est : " + str(ind) + " - " +
answer[ind] + "\n", 1) #log
else:
for ind in list_rep:
if maxCount_exact == rep_exact[ind] and maxCount == count[
ind] and maxCount_exact >= 0: #Maximum exact ET Maximum hash c est la bonne réponse
print(
colored(
"La reponse est : " + str(ind) + " - " +
answer[ind], 'green'))
add_log("La reponse est : " + str(ind) + " - " +
answer[ind] + "\n", 1) #log
else:
if maxCount_exact == rep_exact[
ind] and maxCount_exact >= 0: #Maximum exact
print(
colored(
"La reponse est : " + str(ind) + " - " +
answer[ind], 'yellow'))
add_log("La reponse est : " + str(ind) + " - " +
answer[ind] + "\n", 1) #log
else:
if maxCount == count[ind]: #Maximum hash
print(
colored(
"La reponse est : " + str(ind) + " - " +
answer[ind], 'red'))
add_log("La reponse est : " + str(ind) + " - " +
answer[ind] + "\n", 1) #log
end_time2 = time()
print("Duree recherche : %ssecs" % (end_time2 - start_time2))
print("Duree totale : %ssecs" % (end_time2 - start_time))
#Fermeture du fichier de log
if f_debug >= 1:
add_log("===== fermeture " + str(datetime.now()) + " ====\n", 1) #log
text_file.close
def main():
colorama.init() #turn colorama ANSII conversion on
#wrkr, wrkst, temp, humid, str_start, str_end = gather_info()
wrkr = 'wb'
wrkst = 'wsb-001'
temp = 72.0
humid = 20.0
str_start = 'ST00001'
str_end = 'ST00024'
straw_dict = {}
save_dict = {}
for value in straw_nums:
save_dict[value+'ii'] = [0,0,'',0,0,0,'fail'] #[% error, device resistance, pass/fail]
save_dict[value+'io'] = [0,0,'',0,0,0,'fail'] #[% error, device resistance, pass/fail]
save_dict[value+'oi'] = [0,0,'',0,0,0,'fail'] #[% error, device resistance, pass/fail]
save_dict[value+'oo'] = [0,0,'',0,0,0,'fail'] #[% error, device resistance, pass/fail]
#print('Using first calibration file...\n')
repeat = True
while(repeat == True):
input("Press enter to measure resistance...")
straw_dict = measure_resistance(avg_method, meas_cycles,
str_start, str_end,calib_file)
i = 0
for key, value in sorted(save_dict.items()):
if value[6] != 'pass': #and straw_dict[key][6] == 'pass':
value[0] = straw_dict[key][0]
value[1] = straw_dict[key][1]
value[2] = straw_dict[key][2]
value[3] = straw_dict[key][3]
value[4] = straw_dict[key][4]
value[5] = straw_dict[key][5]
value[6] = straw_dict[key][6]
i += 1
if i == 0:
repeat = False
display_resistance(save_dict)
#repeat = check_repeat()
repeat = False
save_resistance(wrkr, wrkst, temp, humid, save_dict,dataFile,str_start,str_end)
input('Press enter to exit...')
''' This section was used in testing different calibration methods
print('Now using adjusted calibration file...\n')
straw_dict = {}
save_dict = {}
for value in straw_nums:
save_dict[value+'ii'] = [0,0,'',0,0,0,'fail'] #[% error, device resistance, pass/fail]
save_dict[value+'io'] = [0,0,'',0,0,0,'fail'] #[% error, device resistance, pass/fail]
save_dict[value+'oi'] = [0,0,'',0,0,0,'fail'] #[% error, device resistance, pass/fail]
save_dict[value+'oo'] = [0,0,'',0,0,0,'fail'] #[% error, device resistance, pass/fail]
repeat = True
while(repeat == True):
input("Press enter to measure resistance...")
straw_dict = measure_resistance(avg_method, meas_cycles,
str_start, str_end,calib_file_adjusted)
i = 0
for key, value in sorted(save_dict.items()):
if value[6] != 'pass': #and straw_dict[key][6] == 'pass':
value[0] = straw_dict[key][0]
value[1] = straw_dict[key][1]
value[2] = straw_dict[key][2]
value[3] = straw_dict[key][3]
value[4] = straw_dict[key][4]
value[5] = straw_dict[key][5]
value[6] = straw_dict[key][6]
i += 1
if i == 0:
repeat = False
display_resistance(save_dict)
repeat = check_repeat()
save_resistance(wrkr, wrkst, temp, humid, save_dict,dataFile_adjusted)
'''
colorama.deinit() #turn colorama ANSII conversion off
def main():
# Colorama module's initialization.
init(autoreset=True)
version_string = f"%(prog)s {__version__}\n" + \
f"{requests.__description__}: {requests.__version__}\n" + \
f"Python: {platform.python_version()}"
parser = ArgumentParser(
formatter_class=RawDescriptionHelpFormatter,
description=f"{module_name} (Version {__version__})")
parser.add_argument("--version",
action="version",
version=version_string,
help="Display version information and dependencies.")
parser.add_argument(
"--verbose",
"-v",
"-d",
"--debug",
action="store_true",
dest="verbose",
default=False,
help="Display extra debugging information and metrics.")
parser.add_argument(
"--rank",
"-r",
action="store_true",
dest="rank",
default=False,
help=
"Present websites ordered by their Alexa.com global rank in popularity."
)
parser.add_argument(
"--folderoutput",
"-fo",
dest="folderoutput",
help=
"If using multiple usernames, the output of the results will be saved at this folder."
)
parser.add_argument(
"--output",
"-o",
dest="output",
help=
"If using single username, the output of the result will be saved at this file."
)
parser.add_argument(
"--tor",
"-t",
action="store_true",
dest="tor",
default=False,
help=
"Make requests over Tor; increases runtime; requires Tor to be installed and in system path."
)
parser.add_argument(
"--unique-tor",
"-u",
action="store_true",
dest="unique_tor",
default=False,
help=
"Make requests over Tor with new Tor circuit after each request; increases runtime; requires Tor to be installed and in system path."
)
parser.add_argument("--csv",
action="store_true",
dest="csv",
default=False,
help="Create Comma-Separated Values (CSV) File.")
parser.add_argument(
"--site",
action="append",
metavar='SITE_NAME',
dest="site_list",
default=None,
help=
"Limit analysis to just the listed sites. Add multiple options to specify more than one site."
)
parser.add_argument(
"--proxy",
"-p",
metavar='PROXY_URL',
action="store",
dest="proxy",
default=None,
help="Make requests over a proxy. e.g. socks5://127.0.0.1:1080")
parser.add_argument(
"--json",
"-j",
metavar="JSON_FILE",
dest="json_file",
default="data.json",
help="Load data from a JSON file or an online, valid, JSON file.")
parser.add_argument(
"--proxy_list",
"-pl",
metavar='PROXY_LIST',
action="store",
dest="proxy_list",
default=None,
help=
"Make requests over a proxy randomly chosen from a list generated from a .csv file."
)
parser.add_argument(
"--check_proxies",
"-cp",
metavar='CHECK_PROXY',
action="store",
dest="check_prox",
default=None,
help="To be used with the '--proxy_list' parameter. "
"The script will check if the proxies supplied in the .csv file are working and anonymous."
"Put 0 for no limit on successfully checked proxies, or another number to institute a limit."
)
parser.add_argument(
"--print-found",
action="store_true",
dest="print_found_only",
default=False,
help="Do not output sites where the username was not found.")
parser.add_argument(
"username",
nargs='+',
metavar='USERNAMES',
action="store",
help="One or more usernames to check with social networks.")
args = parser.parse_args()
print(Fore.WHITE + Style.BRIGHT + BANNER)
# Argument check
# TODO regex check on args.proxy
if args.tor and (args.proxy != None or args.proxy_list != None):
raise Exception("Tor and Proxy cannot be set in the meantime.")
# Proxy argument check.
# Does not necessarily need to throw an error,
# since we could join the single proxy with the ones generated from the .csv,
# but it seems unnecessarily complex at this time.
if args.proxy != None and args.proxy_list != None:
raise Exception("A single proxy cannot be used along with proxy list.")
# Make prompts
if args.proxy != None:
print("Using the proxy: " + args.proxy)
global proxy_list
if args.proxy_list != None:
print_info("Loading proxies from", args.proxy_list)
proxy_list = load_proxies_from_csv(args.proxy_list)
# Checking if proxies should be checked for anonymity.
if args.check_prox != None and args.proxy_list != None:
try:
limit = int(args.check_prox)
if limit == 0:
proxy_list = check_proxy_list(proxy_list)
elif limit > 0:
proxy_list = check_proxy_list(proxy_list, limit)
else:
raise ValueError
except ValueError:
raise Exception(
"Prameter --check_proxies/-cp must be a positive intiger.")
if args.tor or args.unique_tor:
print("Using Tor to make requests")
print(
"Warning: some websites might refuse connecting over Tor, so note that using this option might increase connection errors."
)
# Check if both output methods are entered as input.
if args.output is not None and args.folderoutput is not None:
print("You can only use one of the output methods.")
sys.exit(1)
# Check validity for single username output.
if args.output is not None and len(args.username) != 1:
print("You can only use --output with a single username")
sys.exit(1)
response_json_online = None
site_data_all = None
# Try to load json from website.
try:
response_json_online = requests.get(url=args.json_file)
except requests.exceptions.MissingSchema: # In case the schema is wrong it's because it may not be a website
pass
# Check if the response is appropriate.
if response_json_online is not None and response_json_online.status_code == 200:
# Since we got data from a website, try to load json and exit if parsing fails.
try:
site_data_all = response_json_online.json()
except ValueError:
print("Invalid JSON from website!")
sys.exit(1)
pass
data_file_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
args.json_file)
# This will be none if the request had a missing schema
if site_data_all is None:
# Check if the file exists otherwise exit.
if not os.path.exists(data_file_path):
print("JSON file at doesn't exist.")
print(
"If this is not a file but a website, make sure you have appended http:// or https://."
)
sys.exit(1)
else:
raw = open(data_file_path, "r", encoding="utf-8")
try:
site_data_all = json.load(raw)
except:
print("Invalid JSON loaded from file.")
if args.site_list is None:
# Not desired to look at a sub-set of sites
site_data = site_data_all
else:
# User desires to selectively run queries on a sub-set of the site list.
# Make sure that the sites are supported & build up pruned site database.
site_data = {}
site_missing = []
for site in args.site_list:
for existing_site in site_data_all:
if site.lower() == existing_site.lower():
site_data[existing_site] = site_data_all[existing_site]
if not site_data:
# Build up list of sites not supported for future error message.
site_missing.append(f"'{site}'")
if site_missing:
print(
f"Error: Desired sites not found: {', '.join(site_missing)}.")
sys.exit(1)
if args.rank:
# Sort data by rank
site_dataCpy = dict(site_data)
ranked_sites = sorted(
site_data,
key=lambda k:
("rank" not in k, site_data[k].get("rank", sys.maxsize)))
site_data = {}
for site in ranked_sites:
site_data[site] = site_dataCpy.get(site)
# Run report on all specified users.
for username in args.username:
print()
if args.output:
file = open(args.output, "w", encoding="utf-8")
elif args.folderoutput: # In case we handle multiple usernames at a targetted folder.
# If the folder doesnt exist, create it first
if not os.path.isdir(args.folderoutput):
os.mkdir(args.folderoutput)
file = open(os.path.join(args.folderoutput, username + ".txt"),
"w",
encoding="utf-8")
else:
file = open(username + ".txt", "w", encoding="utf-8")
# We try to ad a random member of the 'proxy_list' var as the proxy of the request.
# If we can't access the list or it is empty, we proceed with args.proxy as the proxy.
try:
random_proxy = random.choice(proxy_list)
proxy = f'{random_proxy.protocol}://{random_proxy.ip}:{random_proxy.port}'
except (NameError, IndexError):
proxy = args.proxy
results = {}
results = sherlock(username,
site_data,
verbose=args.verbose,
tor=args.tor,
unique_tor=args.unique_tor,
proxy=args.proxy,
print_found_only=args.print_found_only)
exists_counter = 0
for website_name in results:
dictionary = results[website_name]
if dictionary.get("exists") == "yes":
exists_counter += 1
file.write(dictionary["url_user"] + "\n")
file.write("Total Websites : {}".format(exists_counter))
file.close()
if args.csv == True:
with open(username + ".csv", "w", newline='',
encoding="utf-8") as csv_report:
writer = csv.writer(csv_report)
writer.writerow([
'username', 'name', 'url_main', 'url_user', 'exists',
'http_status', 'response_time_ms'
])
for site in results:
writer.writerow([
username, site, results[site]['url_main'],
results[site]['url_user'], results[site]['exists'],
results[site]['http_status'],
results[site]['response_time_ms']
])
def main():
colorama.init(autoreset=True)
c1 = colorama.Fore.BLUE + colorama.Back.LIGHTCYAN_EX
c5 = colorama.Fore.RED + colorama.Back.LIGHTYELLOW_EX
c7 = colorama.Fore.BLACK + colorama.Back.MAGENTA
cr = colorama.Style.RESET_ALL
basic = False
help_me = False
error_msg = None
invalid_cmd = None
language = "English"
command_args = sys.argv[2:]
file_name = command_args[0]
if not file_name.endswith(".py"):
error_msg = 'File Name must end with ".py"!'
elif "*" in file_name or len(str(file_name)) < 4:
error_msg = 'Invalid File Name!'
elif "/" in str(file_name) or "\\" in str(file_name):
error_msg = 'File must be created in the current directory!'
elif os.path.exists(os.getcwd() + '/' + file_name):
error_msg = ('File "%s" already exists in the current path!' %
file_name)
if error_msg:
error_msg = c5 + error_msg + cr
invalid_run_command(error_msg)
if len(command_args) >= 2:
options = command_args[1:]
for option in options:
option = option.lower()
if option == "help" or option == "--help":
help_me = True
elif option == "-b" or option == "--basic":
basic = True
elif option == "--en" or option == "--english":
language = "English"
elif option == "--zh" or option == "--chinese":
language = "Chinese"
elif option == "--nl" or option == "--dutch":
language = "Dutch"
elif option == "--fr" or option == "--french":
language = "French"
elif option == "--it" or option == "--italian":
language = "Italian"
elif option == "--ja" or option == "--japanese":
language = "Japanese"
elif option == "--ko" or option == "--korean":
language = "Korean"
elif option == "--pt" or option == "--portuguese":
language = "Portuguese"
elif option == "--ru" or option == "--russian":
language = "Russian"
elif option == "--es" or option == "--spanish":
language = "Spanish"
else:
invalid_cmd = "\n===> INVALID OPTION: >> %s <<\n" % option
invalid_cmd = invalid_cmd.replace('>> ', ">>" + c5 + " ")
invalid_cmd = invalid_cmd.replace(' <<', " " + cr + "<<")
invalid_cmd = invalid_cmd.replace('>>', c7 + ">>" + cr)
invalid_cmd = invalid_cmd.replace('<<', c7 + "<<" + cr)
help_me = True
break
if help_me:
invalid_run_command(invalid_cmd)
if language != "English" and sys.version_info[0] == 2:
print("")
msg = 'Multi-language support for "sbase mkfile" '
msg += 'is not available on Python 2!'
msg = "\n" + c5 + msg + cr
msg += '\nPlease run in "English" mode or upgrade to Python 3!\n'
raise Exception(msg)
dir_name = os.getcwd()
file_path = "%s/%s" % (dir_name, file_name)
body = "html > body"
para = "body p"
hello = "Hello"
goodbye = "Goodbye"
class_name = "MyTestClass"
if language == "Chinese":
hello = "你好"
goodbye = "再见"
class_name = "我的测试类"
elif language == "Dutch":
hello = "Hallo"
goodbye = "Dag"
class_name = "MijnTestklasse"
elif language == "French":
hello = "Bonjour"
goodbye = "Au revoir"
class_name = "MaClasseDeTest"
elif language == "Italian":
hello = "Ciao"
goodbye = "Addio"
class_name = "MiaClasseDiTest"
elif language == "Japanese":
hello = "こんにちは"
goodbye = "さようなら"
class_name = "私のテストクラス"
elif language == "Korean":
hello = "여보세요"
goodbye = "안녕"
class_name = "테스트_클래스"
elif language == "Portuguese":
hello = "Olá"
goodbye = "Tchau"
class_name = "MinhaClasseDeTeste"
elif language == "Russian":
hello = "Привет"
goodbye = "До свидания"
class_name = "МойТестовыйКласс"
elif language == "Spanish":
hello = "Hola"
goodbye = "Adiós"
class_name = "MiClaseDePrueba"
url = ""
if basic:
url = "about:blank"
elif language not in ["English", "Dutch", "French", "Italian"]:
url = "data:text/html,<meta charset='utf-8'><p>%s <input>" % hello
else:
url = "data:text/html,<p>%s<br><input></p>" % hello
import_line = "from seleniumbase import BaseCase"
parent_class = "BaseCase"
class_line = "class MyTestClass(BaseCase):"
if language != "English":
from seleniumbase.translate.master_dict import MD_F
import_line = MD_F.get_import_line(language)
parent_class = MD_F.get_lang_parent_class(language)
class_line = "class %s(%s):" % (class_name, parent_class)
data = []
data.append("%s" % import_line)
data.append("")
data.append("")
data.append("%s" % class_line)
data.append("")
data.append(" def test_base(self):")
data.append(' self.open("%s")' % url)
if not basic:
data.append(' self.assert_element("%s") # selector' % body)
data.append(' self.assert_text("%s", "%s")'
' # text, selector' % (hello, para))
data.append(' self.type("input", "%s")'
' # selector, text' % goodbye)
data.append(' self.click("%s") # selector' % para)
data.append("")
new_data = []
if language == "English":
new_data = data
else:
from seleniumbase.translate.master_dict import MD
from seleniumbase.translate.master_dict import MD_L_Codes
md = MD.md
lang_codes = MD_L_Codes.lang
nl_code = lang_codes[language]
dl_code = lang_codes["English"]
for line in data:
found_swap = False
replace_count = line.count("self.") # Total possible replacements
for key in md.keys():
original = "self." + md[key][dl_code] + "("
if original in line:
replacement = "self." + md[key][nl_code] + "("
new_line = line.replace(original, replacement)
found_swap = True
replace_count -= 1
if replace_count == 0:
break # Done making replacements
else:
# There might be another method to replace in the line.
# Example: self.assert_true("Name" in self.get_title())
line = new_line
continue
if found_swap:
if new_line.endswith(" # noqa"): # Remove flake8 skip
new_line = new_line[0:-len(" # noqa")]
new_data.append(new_line)
continue
new_data.append(line)
data = new_data
file = codecs.open(file_path, "w+", "utf-8")
file.writelines("\r\n".join(data))
file.close()
success = ('\n' + c1 + '* Test file: "' + file_name + '" was created! *'
'' + cr + '\n')
print(success)
def check_args():
init(autoreset=True)
global CONNECTION_TIMEOUT
global CONNECTION_RETRIES
global SIZE
global INDEXES
global DUMP_INDEXES
global OUTPUT
global STDOUT
global YARA
pars = argparse.ArgumentParser(
description=Fore.GREEN + Style.BRIGHT +
'Search for elasticsearch on the Internet. \nDisplay all Indexes and dump the Indexes.'
+ Style.RESET_ALL)
pars.add_argument('-t',
'--timeout',
nargs='?',
type=int,
default=30,
help='Connection Timeout, Default = 30s')
pars.add_argument('-r',
'--retries',
nargs='?',
type=int,
default=False,
help='Connection Retries, Default = 0')
pars.add_argument('-s',
'--size',
nargs='?',
type=int,
default=1,
help='Define Scroll Size, Default = 1')
pars.add_argument(
'-v',
'--verbose',
type=int,
nargs='?',
help=
'Increase verbosity level 0:INFO, 1:DEBUG, 2:WARNING, 3:ERROR, 4:CRITICAL',
default=None)
pars.add_argument(
'-i',
'--indexes',
type=str,
nargs='*',
help='Give known indexes : index1 index2 indexn, Default = *',
default='*')
pars.add_argument('-d',
'--dump',
type=bool,
nargs='?',
help='Dump indexes of target. Default = False',
default=False,
const=True)
pars.add_argument(
'-o',
'--output',
type=str,
choices=('csv', 'json'),
help='Output File: out/ip/indexname, csv=only _source, json=all',
default=None)
pars.add_argument('-std',
'--stdout',
type=bool,
nargs='?',
help='Display DUMP to stdout, Default = False',
default=False,
const=True)
pars.add_argument('-y',
'--yara',
type=bool,
nargs='?',
help='Turn on yara rule search, Default = False',
default=False,
const=True)
pars.add_argument('--ip', nargs='?', help='Target IP:PORT')
pars.add_argument('-f', '--filename', nargs='?', help='File with IP:PORT')
args = pars.parse_args()
CONNECTION_TIMEOUT = args.timeout
CONNECTION_RETRIES = args.retries
SIZE = args.size
INDEXES = args.indexes
DUMP_INDEXES = args.dump
OUTPUT = args.output
STDOUT = args.stdout
YARA = args.yara
set_debug_level(args.verbose)
print_settings()
if args.ip is None and args.filename is None:
pars.error(Fore.RED + '-f/--filename or --ip required')
elif args.ip and args.filename is None:
return args.ip, True
elif args.ip is None and args.filename:
return args.filename, False
elif args.ip and args.filename:
pars.error(Fore.RED +
'To many Parameters, please choose -f/--filename or --ip')
def main():
arguments = __get_arguments()
path = arguments.path
pattern = arguments.pattern
if path and isfile(path):
path, pattern = split(path)
if not path:
path = os.curdir
if arguments.no_color:
for color_name, value in inspect.getmembers(Fore):
if not color_name.startswith('_'):
setattr(Fore, color_name, '')
if arguments.cover and COVERAGE_AVAILABLE:
cov = coverage(source=arguments.cover_package, omit=arguments.cover_omit)
cov.erase()
cov.start()
verbosity = len(arguments.verbosity) if arguments.verbosity else 2
result, reporter = run(path, pattern, verbosity, arguments.progress)
if result.successful and arguments.cover:
if COVERAGE_AVAILABLE:
cov.stop()
print
print
xml = ''
with tempfile.NamedTemporaryFile() as tmp:
cov.xml_report(outfile=tmp.name)
tmp.seek(0)
xml = tmp.read()
if arguments.cover_report:
with open(arguments.cover_report, 'w') as report:
report.write(xml)
reporter.print_coverage(xml, arguments.cover_threshold)
else:
init(autoreset=True)
print
print Fore.YELLOW + "WARNING: Cover disabled because coverage or lxml could not be found."
print Fore.YELLOW + "Make sure both are installed and accessible"
print
reporter.pretty_print()
if arguments.xunit_output:
xunit = XUnitReporter(result)
xunit.write_report(arguments.xunit_file)
if arguments.profile:
reporter.print_profile()
sys.exit(result.errored_tests)
def run(self):
"""
descrambles tcpdump-binary files, save to h5 in DLSraw standard format
Here is how data are scrambled:
1a) the chips send data out interleaving RowGroups
(7row x (32 Col x 45 pads) ) from Sample/Reset, as:
Smpl, Smpl, Smpl, Rst, Smpl, Rst, ... , Smpl, Rst, Rst, Rst
1b) the position of pixels (pix0/1/2 in the next point) is mapped to
the (7row x 32 Col) block according to the adc_cols lost
1c) inside a (7row x 32 Col) block, the data are streamed out as:
bit0-of-pix0, bit0-of-pix1, bit0-of-pix2, ... , bit0-of-pix1, ...
1d) all the data coming from the sensor are bit-inverted: 0->1; 1->0
2a) the mezzanine takes the data coming from each (7 x 32) block,
and add a "0" it in front of every 15 bits:
xxx xxxx xxxx xxxx yyy ... => 0xxx xxxx xxxx xxxx 0yyy ...
2b) the mezzanine takes the data coming from a 44x (7 x 32) blocks
(this corresponds to a complete RowCrp, ignoring RefCol )
and interleaves 32 bits at a time:
32b-from-pad1, 32b-from-pad2, ... , 32b-from-pad44,
next-32b-from-pad1, next-32b-from-pad2, ...
2c) the mezzanine packs the bits in Bytes, and the Bytes in UDPackets
4 UDPackets contain all the bits of a 44x (7 x 32) Rowgrp.
A complete image (Smpl+Rst) = 1696 UDPackets
each UDPack has 4928Byte of information, and 112Byte of header.
each UDPack is univocally identified by the header:
- whether it is part of a Smpl/Rst
- which Img (frame) the packet belongs to
- its own packet number (0:1696), which determines the RowGrp the
packet's data goes into
3a) the packets are sent from 2 mezzanine links (some on one link, some
on the other), and are saved a 2 binary files by tcpdump
24Bytes are added at the start of each file
Args:
filenamepath_in0/1/2: name of tcpdump scrambled binary files
Might exist or not
output_fname: name of h5 descrambled file to generate
save_file/debugFlag/clean_memory/verbose: no need to explain
Returns:
creates a h5 file (if save_file) in DLSraw standard format
no explicit return()
"""
init(autoreset=True)
start_time = time.strftime("%Y_%m_%d__%H:%M:%S")
print(Fore.BLUE + "Script beginning at {}".format(start_time))
self._report_arguments()
file_content = self._reading_file_content()
n_packets = [len(content) // self._fullpack_size
for content in file_content]
if self._verbose:
print(Fore.GREEN +
("data read from files ({} packets)"
.format("+".join([str(n) for n in n_packets]))))
# search for 1st & last image: this is needed to resort the data from
# the file in a proper array of (n_img, n_pack)
# also scan for fatal packet error: if a packet has a number > 1695
# then the data is corrupted
if self._verbose:
print(Fore.BLUE + "scanning files for obvious packet errors")
first_img, last_img = self._scanning_files(n_packets, file_content)
# if needed, reduce Img2show to the 1st image
# (the 1st img in the sequence might have a Img_counter number >0)
imgs_tcpdump = np.arange(first_img, last_img + 1)
n_img = len(imgs_tcpdump)
msg = (("The lowest-numbered Img of the sequence is: "
"tcpdump-Image {}\n"
"The highest-numbered Img of the sequence is: "
"tcpdump-Image {}").format(first_img, last_img))
print(Fore.GREEN + msg)
# solving the 2c-part of scrambling
# resort data from files (assign pack to its Img,Smpl/Rst)
if self._verbose:
print(Fore.BLUE + "resorting packages")
data, _, pack_check = self._resorting_data(n_img,
imgs_tcpdump,
file_content)
if self._verbose:
print(Fore.BLUE + " ")
if self._clean_memory:
del file_content
# missing package detail: (pack,Img) not flagged as good, are missing
for i, img in enumerate(imgs_tcpdump):
if self._verbose:
missing_packages = np.sum(np.logical_not(pack_check[i, :]))
if missing_packages < 1:
print(Fore.GREEN +
"All packets for image {} are there".format(img))
else:
print(Fore.MAGENTA +
("{} packets missing from image {}"
.format(missing_packages, img)))
# at this point the dsata from the 2 files is ordered in a array of
# dinesion (n_img, n_pack)
# 1 rowgrp = 4 packets
# when a packet is missing, the whole rowgrp is compromised
# if so, flag the 4-tuple of packets (i.e. the rowgrp), as bad
rowgrp_check = (pack_check[:, 0::4]
& pack_check[:, 1::4]
& pack_check[:, 2::4]
& pack_check[:, 3::4])
# - - -
if self._verbose:
print(Fore.BLUE + "descrambling images")
descrambled_data = self._descrambling_images(n_img,
imgs_tcpdump,
data)
if self._verbose:
print(Fore.BLUE + " ")
# solving the 1b-part of scrambling:
# reorder pixels and pads
if self._verbose:
print(Fore.BLUE + "reordering pixels")
self._result_data = self._reordering_pixels(n_img,
imgs_tcpdump,
descrambled_data,
rowgrp_check)
# save data to single file
if self._save_file:
self._save_data()
# save data to multiple file
if self._multiple_save_files:
if self._verbose:
print(Fore.BLUE + "saving to multiple files")
if os.path.isfile(self._multiple_metadata_file) is False:
msg = "metafile file does not exist"
print(Fore.RED + msg)
raise Exception(msg)
meta_data = np.genfromtxt(self._multiple_metadata_file,
delimiter='\t',
dtype=str)
fileprefix_list = meta_data[:, 1]
aux_n_of_files = len(fileprefix_list)
if (aux_n_of_files * self._multiple_imgperfile) != n_img:
msg = ("{} != {} x {} ".format(n_img,
aux_n_of_files,
self._multiple_imgperfile))
print(Fore.RED + msg)
msg = ("n of images != metafile enties x Img/file ")
print(Fore.RED + msg)
raise Exception(msg)
# ...
(sample, reset) = utils.convert_gncrsfn_to_dlsraw(self._result_data,
self._err_int16,
self._err_dlsraw)
(aux_nimg, aux_nrow, aux_ncol) = sample.shape
shape_datamultfiles = (aux_n_of_files,
self._multiple_imgperfile,
aux_nrow,
aux_ncol)
sample = sample.reshape(shape_datamultfiles).astype('uint16')
reset = reset.reshape(shape_datamultfiles).astype('uint16')
for i, prefix in enumerate(fileprefix_list):
filepath = os.path.dirname(self._output_fname)+'/'+prefix + ".h5"
with h5py.File(filepath, "w", libver='latest') as my5hfile:
my5hfile.create_dataset('/data/', data=sample[i, :, :, :])
my5hfile.create_dataset('/reset/', data=reset[i, :, :, :])
if self._verbose:
print(Fore.GREEN + "{0} Img saved to file {1}".format(
self._multiple_imgperfile, filepath))
# that's all folks
print("------------------------")
print("done")
stop_time = time.strftime("%Y_%m_%d__%H:%M:%S")
print(Fore.BLUE + "script ended at {}".format(stop_time))
print("------------------------\n" * 3)
def buysell(key, secret, redis_password):
import time, json, sys, redis
from pprint import pprint
from time import gmtime, strftime
from bittrex import bittrex
from colors import white, red, green, yellow
from colorama import Fore, Back, Style, init
init()
try:
r = redis.Redis(host='redis.pontstrader.com', port=6380, db=0, password=redis_password)
except:
white('Unable to connect to redis.pontstrader.com, trying redis2.pontstrader.com...')
try:
r = redis.Redis(host='redis2.pontstrader.com', port=6380, db=0, password=redis_password)
except:
white('Unable to connect to redis2.pontstrader.com... I am sorry but you can not continue now, please contact p0nts!')
while True:
try:
api = bittrex(key, secret)
currencies = api.getcurrencies()
markets = api.getmarkets()
except:
white('Bittrex API error: {0}'.format(api))
white('Going back to Main Menu')
time.sleep(2)
break
white((30 * '-'))
green(' B U Y A N D S E L L')
white((30 * '-'))
white('Market?')
yellow('1. BTC')
yellow('2. ETH')
yellow('3. USDT')
red('4. Back to Main Menu')
try:
trade = raw_input(Fore.WHITE+'Enter your choice [1-4] : ')
trade = int(trade)
except:
white('\nInvalid number... going back to Main Menu')
time.sleep(1)
break
if trade == 1:
trade = 'BTC'
elif trade == 2:
trade = 'ETH'
elif trade == 3:
trade = 'USDT'
elif trade == 4:
break
else:
white('\nInvalid number... going back to Main Menu')
time.sleep(1)
break
try:
currency = raw_input(Fore.WHITE+'Currency? (e.g. LTC / NEO / OMG) : ').upper()
except:
white('Invalid currency... going back to Main Menu')
time.sleep(1)
break
try:
market = '{0}-{1}'.format(trade, currency)
available = api.getbalance(trade)
except:
print available
white('\nGoing back to Main Menu')
time.sleep(2)
break
try:
values = r.hmget(market, 'Last', 'Bid', 'Ask')
last = float(values[0])
bid = float(values[1])
ask = float(values[2])
white((30 * '-'))
white('- Price (Last): {0:.8f} {1}'.format(last, trade))
white('- Price (Bid): {0:.8f} {1}'.format(bid, trade))
white('- Price (Ask): {0:.8f} {1}'.format(ask, trade))
except:
white('Unable to retrieve latest pricing from redis.pontstrader.com')
white('Going back to Main Menu')
time.sleep(2)
break
for f in currencies:
if f['Currency'] == currency:
fee = f['TxFee']
trade_fee = last * fee
white('- Fee {0:.8f} {1} ({2:.8f} {3})'.format(fee, currency, trade_fee, trade))
for m in markets:
if m['MarketCurrency'] == currency and m['BaseCurrency'] == trade:
minimum = m['MinTradeSize']
white('- Minimum ({0}): {1:.8f}'.format(currency, minimum))
white('- Minimum ({0}): 0.00100000'.format(trade))
enough = trade_fee + 0.00100000 + last
if available['Available'] < 0.00100000:
red('You dont have enough {0} ({1:.8f}) to buy anything!'.format(trade, available['Available']))
time.sleep(1)
break
else:
available_after_fee = available['Available'] - trade_fee
yellow('You have {0:.8f} {1} available in total'.format(available['Available'], trade))
yellow('Which is {0:.8f} {1} exclusive required fee'.format(available_after_fee, trade))
can_buy_last = available_after_fee / last
can_buy_bid = available_after_fee / bid
can_buy_ask = available_after_fee / ask
green('You can buy up to {0:.8f} {1} for \'Last\' price'.format(can_buy_last, currency))
green('You can buy up to {0:.8f} {1} for \'Bid\' price'.format(can_buy_bid, currency))
green('You can buy up to {0:.8f} {1} for \'Ask\' price'.format(can_buy_ask, currency))
white((30 * '-'))
white('Buyprice?')
yellow('1. Last ({0:.8f} {1})'.format(last, trade))
yellow('2. Bid ({0:.8f} {1})'.format(bid, trade))
yellow('3. Ask ({0:.8f} {1})'.format(ask, trade))
yellow('4. Custom')
red('5. Back to Main Menu')
try:
buyprice = raw_input(Fore.WHITE+'Enter your choice [1-5] : ')
buyprice = int(buyprice)
except:
white('ERROR: Please select a number!')
break
if buyprice == 1:
buy_for = last
white('Selected \'Last\': {0:.8f} {1}'.format(last, trade))
elif buyprice == 2:
buy_for = bid
white('Selected \'Bid\': {0:.8f} {1}'.format(bid, trade))
elif buyprice == 3:
buy_for = ask
white('Selected \'Ask\': {0:.8f} {1}'.format(ask, trade))
elif buyprice == 4:
try:
buy_for = raw_input(Fore.WHITE+'Buyprice? e.g. [0.00000001] : ')
buy_for = float(buy_for)
white('Selected \'Custom\': {0:.8f} {1}'.format(buy_for, trade))
except:
white('Please provide a proper buyprice! (e.g. {0:.8f})'.format(last))
break
elif buyprice == 5:
break
else:
white('\nInvalid number... going back to Main Menu')
time.sleep(1)
break
try:
amount = raw_input(Fore.WHITE+'Amount? : ')
amount = float(amount)
except:
white('\nInvalid number... going back to Main Menu')
time.sleep(1)
break
try:
multiplier = float(raw_input(Fore.WHITE+'Multiplier? [1.1 / 1.3] (1.1 = 10%) : '))
multiprice = round(buy_for*multiplier, 8)
multitotal = float(amount) * float(multiprice)
total = float(amount) * float(buy_for)
print (30 * '-')
green('Going to add a buy order for {0:.8f} {1} at {2:.8f} {3} each (total: {4:.8f} {3})'.format(amount, currency, buy_for, trade, total))
green('Going to add a sell order for {0:.8f} {1} at {2:.8f} {3} each (total: {4:.8f} {3})'.format(amount, currency, multiprice, trade, multitotal))
except:
white('ERROR: Amount must be a number!')
white((30 * '-'))
white('Proceed?')
green('1. yes')
red('2. no (Back to Main Menu)')
try:
yes_no = raw_input(Fore.WHITE+'Enter your choice [1-2] : ')
yes_no = int(yes_no)
except:
white('\nInvalid number... going back to Main Menu')
time.sleep(1)
break
if yes_no == 1:
try:
apicall = api.buylimit(market, amount, buy_for)
print apicall['uuid']
uuid = apicall['uuid']
total = amount * buy_for
green('Added a buy order for {0:.8f} {1} at {2:.8f} {3} each which is {4:.8f} {3} total'.format(amount, currency, buy_for, trade, total))
except:
white('Bittrex API error: {0}'.format(apicall))
white('Going back to Main Menu')
time.sleep(2)
break
yellow('Waiting up to 60 seconds for the buy order to be filled...')
yellow('If the buy order will not be filled for 100% I am unable to add the sell order...')
t_end = time.time() + 60
orderstatus = api.getorder(uuid=uuid)
while orderstatus['QuantityRemaining'] != 0.0 and time.time() < t_end:
orderstatus = api.getorder(uuid=uuid)
if orderstatus['QuantityRemaining'] == 0.0:
white('Great, order is completely filled!')
try:
apicall = api.selllimit(market, amount, multiprice)
except:
white('Bittrex API error: {0}'.format(apicall))
white('Going back to Main Menu')
time.sleep(2)
break
print apicall['uuid']
total = amount * multiprice
green('Added a sell order for {0:.8f} {1} at {2:.8f} {3} each which is {4:.8f} {3} total'.format(amount, currency, multiprice, trade, total))
white('Returning to Main Menu in 2 seconds...')
time.sleep(2)
break
else:
time.sleep(10)
red('Unable to add a sell order, because the buy order is not \'completely\' filled, You will have to do this manually as soon as the buy order is completely filled!')
yellow('Please keep in mind the buy order remains untill cancelled or filled!')
white('Returning to Main Menu in 2 seconds...')
time.sleep(2)
break
elif yes_no == 2:
white('\nCancelled... going back to Main Menu')
time.sleep(1)
break
else:
white('\nInvalid number... going back to Main Menu')
time.sleep(1)
break
LIGHTBLUE_EX='',
LIGHTCYAN_EX='',
LIGHTGREEN_EX='',
LIGHTMAGENTA_EX='',
LIGHTRED_EX='',
LIGHTWHITE_EX='',
LIGHTYELLOW_EX='')
DummyStyle = SimpleNamespace(
RESET_ALL='', BRIGHT='', DIM='', NORMAL=''
) #, BOLD='', ITALIC='', UNDERLINE='', BLINKING='', INVERSE='', INVISIBLE='', STRIKETHROUGH='')
# normal color namespaces
try:
import colorama
from colorama import Fore, Back, Style
colorama.init(
) # comment out init if extended color support is needed in Windows Terminal
except ImportError:
# colorama not installed. fine, I'll do it myself
# this expects Windows Terminal or equivalent terminal color code support
Fore = SimpleNamespace(RESET='\x1b[39m',
BLACK='\x1b[30m',
BLUE='\x1b[34m',
CYAN='\x1b[36m',
GREEN='\x1b[32m',
MAGENTA='\x1b[35m',
RED='\x1b[31m',
WHITE='\x1b[37m',
YELLOW='\x1b[33m',
LIGHTBLACK_EX='\x1b[90m',
LIGHTBLUE_EX='\x1b[94m',
LIGHTCYAN_EX='\x1b[96m',
def main():
global rn # Result number (for -r arg)
global ir # interactive mode off (for -i arg)
global tag # tag based search (for -t arg)
global query # query variable
colorama.init() # for colorama support in windows
fixCodePage() # For fixing codepage errors in windows
# IF there is no command line options or if it is help argument:
if (len(sys.argv) == 1) or ((sys.argv[1] == "-h") or
(sys.argv[1] == "--help")):
helpman()
sys.exit(0)
else:
try:
options, rem = getopt.getopt(
sys.argv[1:], "nit:r:q:",
["query=", "res=", "interactive", "new", "tag="])
except getopt.GetoptError:
helpman()
sys.exit(1)
# Gets the CL Args
if 'options' in locals():
for opt, arg in options:
if opt in ("-i", "--interactive"):
ir = 1 # interactive mode on
if opt in ("-r", "--res"):
try:
rn = int(arg)
except ValueError:
print_warning("Wrong syntax...!\n")
helpman()
sys.exit(0)
if opt in ("-t", "--tag"):
if len(arg) == 0:
print_warning("Wrong syntax...!\n")
helpman()
sys.exit(0)
tag = arg
hastags()
if opt in ("-q", "--query"):
query = arg
if len(rem) > 0:
query = query + " " + " ".join(rem)
if opt in ("-n", "--new"):
import webbrowser
print_warning("Opening stack overflow in your browser...")
webbrowser.open(sourl + "/questions/ask")
sys.exit(0)
if tag != "":
wrongsyn(query)
if (rn == -1) and (ir == 0) and tag == "":
if sys.argv[1] in ['-q', '--query']:
socli(" ".join(sys.argv[2:]))
else:
socli(" ".join(sys.argv[1:]))
elif (rn > 0):
wrongsyn(query)
socl_manusearch(query, rn)
sys.exit(0)
elif (rn == 0):
print_warning(
"Count starts from 1. Use: \"socli -i 2 -q python for loop\" for the 2nd result for the query"
)
sys.exit(0)
elif (ir == 1):
wrongsyn(query)
socli_interactive(query)
sys.exit(0)
elif query != "":
socli(query)
sys.exit(0)
else:
print_warning("Wrong syntax...!\n")
helpman()
sys.exit(0)
