def current_month_task_analysis():
now = datetime.datetime.now()
no_of_days_current_month = calendar.monthrange(now.year, now.month)[1]
total_tasks = 0
total_incomplete_tasks = 0
list_of_files = list_of_tasks_files()
for i in range(0, len(list_of_files)):
list_of_files[i] = os.path.join(DIARY_CONFIG_FOLDER_PATH,
list_of_files[i])
for i in list_of_files:
with open(i, 'r') as fp:
contents = yaml.load(fp)
for entry in contents['entries']:
total_tasks += 1
total_incomplete_tasks += (1 if entry['status'] == 0 else 0)
if total_tasks != 0:
percent_incomplete_task = total_incomplete_tasks * 100 / total_tasks
percent_complete_task = 100 - percent_incomplete_task
entry_frequency = total_tasks * 100 / no_of_days_current_month
else:
percent_complete_task = 'NA'
percent_incomplete_task = 'NA'
entry_frequency = 0
chalk.red('Percentage of incomplete task : ' +
str(percent_incomplete_task))
chalk.green('Percentage of complete task : ' + str(percent_complete_task))
chalk.blue("Frequency of adding task (Task/Day) : " + str(entry_frequency))
async def start_somewhere(runner):
print("Searching for an open port...")
for port in range(48654, 49150):
if port == 49000: # reserved
continue
site = web.TCPSite(runner, "", port)
try:
await site.start()
except Exception as e:
print(chalk.red(f"Unable to start on port {port}: {e}"))
continue
print(chalk.green(f"Started server on port {port} successfully!"))
break
else:
print(chalk.red("Could not use any available port."))
raise SystemExit(1)
print("Opening port via UPnP...")
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 10
upnp.discover()
upnp.selectigd()
if upnp.addportmapping(port, "TCP", upnp.lanaddr, port, "PijulGit proxy",
""):
print(chalk.green(f"Opened port {port} successfully!"))
else:
print(chalk.red(f"Failed to open port {port} :("))
return site, port
def dep_with(account: act) -> int:
# parameters work with welcome()
while True:
chalk.green("""
What would you like to do?
=====*=====*=====*=====*=====*=====*=====*=====*=====*=====
Deposit to checking: press 1 ➤
Deposit to savings: press 2 ➤
Withdrawal from checking: press 3 ➤
Withdrawal from savings: press 4 ➤
""")
choose = int(input('Enter ➤➤ '))
if choose == 1:
chalk.magenta("Enter deposit amount:") # Deposit to checking
new_dep = int(input('➤➤ '))
# except ValueError:
# pass
dep_amount = account.deposit(new_dep)
new_balance = account.get_funds()
chalk.magenta(f"""{dep_amount} has been deposited to your account.
Your new balance is {new_balance}.""")
elif choose == 2:
chalk.magenta("Enter deposit amount:") # Deposit to savings
new_svgs_dep = int(input('➤➤ '))
svgs_dep_amount = account.deposit(new_svgs_dep)
svgs_new_balance = account.get_funds()
chalk.magenta(f"""{svgs_dep_amount} has been deposited to your account.
Your new balance is {svgs_new_balance}.""")
elif choose == 3:
chalk.magenta("Enter withdrawal amount:") # Withdrawal from checking
new_withdra = int(input('➤➤ '))
account.withdrawal(new_withdra)
new_balance = account.get_funds()
chalk.magenta(f"""{new_withdra} has been withdrawn from your account.
Your new balance is {new_balance}.""")
elif choose == 4:
chalk.magenta("Enter withdrawal amount:") # Withdrawal from savings
svgs_new_withdra = int(input('➤➤ '))
account.withdrawal(svgs_new_withdra)
svgs_new_balance = account.get_funds()
chalk.magenta(f"""{svgs_new_withdra} has been withdrawn from your account.
Your new balance is {svgs_new_balance}.""")
# except ValueError as error:
# chalk.red(error.args[0])
return another_trans(account=account) # how affect svgs_account
def tasks():
if os.path.isfile(TODAYS_TASKS_ENTRY_FILE_PATH):
click.echo('Today\'s agenda:')
click.echo('----------------')
click.echo("Status | Time | Text")
click.echo("-------|---------|-----")
incomplete_tasks = 0
total_tasks = 0
with open(TODAYS_TASKS_ENTRY_FILE_PATH, 'r') as todays_tasks_entry:
contents = yaml.load(todays_tasks_entry)
for entry in contents['entries']:
total_tasks += 1
incomplete_tasks += (1 if entry['status'] == 0 else 0)
time = entry['time']
text = entry['text'] if entry['status'] == 0 else strike(
entry['text'])
status = "O" if entry['status'] == 0 else "X"
click.echo(" " + status + " | " + time + ": " + text)
click.echo('----------------')
click.echo('')
click.echo('Summary:')
click.echo('----------------')
if incomplete_tasks == 0:
chalk.green(
'All tasks have been competed! Add a new task by entering "dude diary nt"'
)
else:
chalk.red("Incomplete tasks: " + str(incomplete_tasks))
chalk.green("Completed tasks: " +
str(total_tasks - incomplete_tasks))
else:
click.echo(
'There are no tasks for today. Add a new task by entering "dude diary nt"'
)
def launch(*args, **options):
"launch acts on the user specified action and options by executing Hedrix.run"
action = args[0]
if options['reload']:
event_handler = Reload(options)
observer = Observer()
observer.schedule(event_handler, path='.', recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
pid = os.getpid()
chalk.eraser()
chalk.green('\nHendrix successfully closed.')
os.kill(pid, 15)
observer.join()
exit('\n')
else:
try:
deploy = HendrixDeploy(action, options)
deploy.run()
except Exception, e:
if options.get('traceback'):
tb = sys.exc_info()[2]
msg = traceback.format_exc(tb)
else:
msg = str(e)
chalk.red(msg, pipe=chalk.stderr)
os._exit(1)
async def on_ready(self): #When the bot is ready
print("\n")
print(chalk.green(f"[SUCCESS] Connected to Discord as: {self.b.user}"))
if conf.sharding is False: #If sharding is disabled
print(chalk.red(f"[WARNING] Sharding: Disabled"))
elif conf.sharding is True: #If sharding is Enabled
print(chalk.green("[INFO] Sharding: Enabled"))
print(chalk.yellow(f"[INFO] Using SHARD's {self.b.shard_ids}")
) #Shows us how many shards we are currently using
print(chalk.cyan(f"[INFO] Config name: '{conf.name}'")
) #Shows us the name defined in the config
print(
chalk.cyan(
f"[INFO] Default Prefix: 'Prefix 1: {conf.prefix1} | Prefix 2: {conf.prefix2}'"
)) #Shows us the 2 prefixes defined in the config
print(chalk.cyan("[INFO] Are you braindead: Most Likely")) #Yup
print(
chalk.cyan(
f"[INFO] I'm currently in [{len(self.b.guilds)}] server(s).")
) #Shows us how many servers we are in
aaa = True
for guild in self.b.guilds: #Set all guild the doki is in to have triggers enabled on startup otherwise they no be in list which means triggers are off.
conf.w_tog_on.insert(0, guild.id)
while aaa: #A loop to make the game activity change every 900 seconds
for list in conf.playing_msg:
await self.b.change_presence(activity=discord.Game(name=list))
await asyncio.sleep(900)
def book_catalog():
"""
gather text file titles from path to a folder, offer user choice to pick a title, send that choice to
file_opener
:return: None
"""
book_list = [book for book in os.listdir(BOOKS) if '.txt' in book]
menu_text = f"""To compute its automated readability index,
pick from one of the files below:\n"""
options = {index: book for index, book in enumerate(book_list, start=1)}
options.update({'q)': 'quit'})
chalk.green(menu_text)
for index, book in options.items():
print(f'{index}) {book}')
choice = int(input("Enter number choice here >>> "))
lookup_title = options.get(
choice
) # gets choice of text file title from book_list stores in lookup_title
full_path = BOOKS + lookup_title # concats BOOKS URL with text file name and stores in full_path
text = file_opener(
full_path
) # full text url path is passed to file_opener function to display text
score = compute_ari(
text
) # text passed to compute_ari where it's cleaned, counted and computed with ARI equation
output(
score, lookup_title
) # final output score and ranking printed to screen, pass text title name for final print out
def DjangoStaticResource(path, rel_url='static'):
"""
takes an app level file dir to find the site root and servers static files
from static
Usage:
[...in app.resource...]
from hendrix.resources import DjangoStaticResource
StaticResource = DjangoStaticResource('/abspath/to/static/folder')
... OR ...
StaticResource = DjangoStaticResource(
'/abspath/to/static/folder', 'custom-static-relative-url'
)
[...in settings...]
HENDRIX_CHILD_RESOURCES = (
...,
'app.resource.StaticResource',
...
)
"""
rel_url = rel_url.strip('/')
StaticFilesResource = MediaResource(path)
StaticFilesResource.namespace = rel_url
chalk.green(
"Adding media resource for URL '%s' at path '%s'" % (rel_url, path)
)
return StaticFilesResource
def DjangoStaticResource(path, rel_url='static'):
"""
takes an app level file dir to find the site root and servers static files
from static
Usage:
[...in app.resource...]
from hendrix.resources import DjangoStaticResource
StaticResource = DjangoStaticResource('/abspath/to/static/folder')
... OR ...
StaticResource = DjangoStaticResource(
'/abspath/to/static/folder', 'custom-static-relative-url'
)
[...in settings...]
HENDRIX_CHILD_RESOURCES = (
...,
'app.resource.StaticResource',
...
)
"""
rel_url = rel_url.strip('/')
StaticFilesResource = MediaResource(path)
StaticFilesResource.namespace = rel_url
chalk.green(
"Adding media resource for URL '%s' at path '%s'" % (rel_url, path)
)
return StaticFilesResource
async def embed(ctx, *, a_sMessage):
embed = discord.Embed(description=a_sMessage, color=0xffdd00)
embed.set_thumbnail(url=ctx.message.author.avatar_url)
embed.set_author(name=ctx.message.author.name + " says..")
embed.set_footer(text="Fox 0.3")
await bot.delete_message(ctx.message)
await bot.say(embed=embed)
chalk.green(ctx.message.author.name + " has embedded a message in " + ctx.message.server.name)
def thread_init():
if len(THREAD_CONFIG):
chalk.green('current time: %r' % utc_now())
chalk.green('Found %d thread(s) specified by THREAD_CONFIG' %
len(THREAD_CONFIG))
for index, thread_group_list in enumerate(THREAD_CONFIG):
tm = ThreadManager(index, thread_group_list)
tm.start()
def stat_printer(rain_stat: tuple) -> None:
"""display results"""
date, rain_amount = rain_stat[0], int(rain_stat[1][0] / 24)
year, month, day = date[-4:], date[3:6].capitalize(), date[1:2]
chalk.red(f"{month}. {day}, {year} had the most rain with {rain_amount} hunderedths of an inch on an hourly average.")
chalk.green(f"The year with the most rain was {year} with {rain_amount} inches of rain.")
def thread_init():
if len(THREAD_CONFIG):
chalk.green('current time: %r' % utc_now())
chalk.green(
'Found %d thread(s) specified by THREAD_CONFIG' % len(THREAD_CONFIG)
)
for index, thread_group_list in enumerate(THREAD_CONFIG):
tm = ThreadManager(index, thread_group_list)
tm.start()
def stop(self, sig=9):
with open(self.pid) as pid_file:
pids = pid_file.readlines()
for pid in pids:
try:
os.kill(int(pid), sig)
except OSError:
# OSError raised when it trys to kill the child processes
pass
os.remove(self.pid)
chalk.green('Stopping Hendrix...')
def stop(self, sig=9):
with open(self.pid) as pid_file:
pids = pid_file.readlines()
for pid in pids:
try:
os.kill(int(pid), sig)
except OSError:
# OSError raised when it trys to kill the child processes
pass
os.remove(self.pid)
chalk.green('Stopping Hendrix...')
def thread_init():
if len(THREAD_CONFIG):
chalk.green('current time: %r' % utc_now())
chalk.green(
'Found %d thread(s) specified by THREAD_CONFIG' % len(THREAD_CONFIG)
)
for index, thread_group_list in enumerate(THREAD_CONFIG):
runner = Runner(index, thread_group_list)
tiempo_loop.start()
async def pullPijul(url):
# Check whether we have the repo downloaded already
path = urlToPath(url)
if os.path.isdir(path):
print(f" Pijul: Fetching {url} to {path}...")
await run(f"cd {path}; pijul pull --all")
print(chalk.green(" Done."))
else:
print(f" Pijul: Cloning {url} to {path}...")
await run(
f"mkdir {path}; cd {path}; pijul init; pijul pull --set-default --set-remote origin \"{url}\" --all"
)
print(chalk.green(" Done."))
async def on_ready(self):
botguild = next((item for item in self.bot.guilds if item.id == 615228970568515626), None)
log = botguild.get_channel(625767405641007106)
if not hasattr(self.bot, 'uptime'):
self.bot.uptime = datetime.utcnow()
print(chalk.bold(chalk.cyan('Ready: ')) + chalk.green(f'{self.bot.user}') + chalk.yellow(' | ') + chalk.bold(
chalk.cyan('Servers: ')) + chalk.green(
f'{len(self.bot.guilds)}'))
await self.bot.change_presence(activity=discord.Game(type=0, name=self.config.playing),
status=discord.Status.online)
await log.send(f'```css\nReady! Guilds: {len(self.bot.guilds)}```')
def responseInColor(request, status, headers, prefix='Response', opts=None):
"Prints the response info in color"
code, message = status.split(None, 1)
message = '%s [%s] => Request %s %s %s on pid %d' % (
prefix, code, str(
request.host), request.method, request.path, os.getpid())
signal = int(code) / 100
if signal == 2:
chalk.green(message, opts=opts)
elif signal == 3:
chalk.blue(message, opts=opts)
else:
chalk.red(message, opts=opts)
def battle(good_guy, bad_guy):
bad_guy_name = bad_guy.get_kind().title()
good_guy_name = good_guy.get_kind().title()
print(chalk.green(f"You are attacking a {bad_guy.get_kind()}, armed with a {bad_guy.get_weapon()}"))
print(chalk.green("here are it's stats..."))
print(chalk.green(bad_guy))
ans = answer_question('Would you like to attack or run away (a/r)?', ['a', 'r'])
while ans == 'a':
rps_dictionary = {'r': 'rock', 'p': 'paper', 's': 'scissors'}
ans = answer_question('Choose rock, paper, or scissors (r/p/s)', ['r', 'p', 's'])
good_guy_choice = rps_dictionary[ans]
bad_guy_choice = random.choice(['rock', 'paper', 'scissors'])
print(chalk.green(f'You chose {good_guy_choice} and the enemy chose {bad_guy_choice}'))
if bad_guy_choice == good_guy_choice:
print(chalk.green("It's a tie! Do over!"))
elif bad_guy_choice == 'rock' and good_guy_choice == 'paper':
print(chalk.green("You've struck a blow! Good job!"))
bad_guy.update_health(-1 * good_guy.get_attack_power())
elif bad_guy_choice == 'paper' and good_guy_choice == 'scissors':
print(chalk.green("You've struck a blow! Good job!"))
bad_guy.update_health(-1 * good_guy.get_attack_power())
elif bad_guy_choice == 'scissors' and good_guy_choice == 'rock':
print(chalk.green("You've struck a blow! Good job!"))
bad_guy.update_health(-1 * good_guy.get_attack_power())
elif bad_guy_choice == 'scissors' and good_guy_choice == 'paper':
print(chalk.red("You've taken a hit. Ouch!"))
good_guy.update_health(-1 * bad_guy.get_attack_power())
elif bad_guy_choice == 'paper' and good_guy_choice == 'rock':
print(chalk.red("You've taken a hit. Ouch!"))
good_guy.update_health(-1 * bad_guy.get_attack_power())
elif bad_guy_choice == 'rock' and good_guy_choice == 'scissors':
print(chalk.red("You've taken a hit. Ouch!"))
good_guy.update_health(-1 * bad_guy.get_attack_power())
if hero.get_health() <= 0:
print_image('died_in_battle.txt')
return good_guy, bad_guy
elif bad_guy.get_health() <= 0:
print_image('won_the_battle.txt')
return good_guy, Thing(bad_guy.get_weapon(), bad_guy.get_location(), False, False)
battle_status = good_guy_name + ': ' + str(good_guy.get_health()) + ' vs. ' + bad_guy_name + ': ' \
+ str(bad_guy.get_health())
if good_guy.get_health() > 35:
print(chalk.green(battle_status))
elif good_guy.get_health() > 10:
print(chalk.yellow(battle_status))
else:
print(chalk.red(battle_status))
ans = answer_question('Would you like to attack or run away (a/r)?', ['a', 'r'])
return hero, bad_guy
async def reload(ctx):
for extension in extensions:
try:
bot.unload_extension(f"cogs.{extension}")
print(chalk.green(f"cogs.{extension} unloaded"))
await ctx.send(f"cogs.{extension} unloaded")
bot.load_extension(f"cogs.{extension}")
print(chalk.green(f"cogs.{extension} loaded"))
await ctx.send(f"cogs.{extension} loaded")
except Exception as error:
print(chalk.red(f"{extension} cannot be loaded. {error}"))
def complete_task():
not_valid_task_number = 1
if os.path.isfile(TODAYS_TASKS_ENTRY_FILE_PATH):
with open(TODAYS_TASKS_ENTRY_FILE_PATH, 'r') as todays_tasks_entry:
contents = yaml.load(todays_tasks_entry)
i = 0
no_task_left = True
for entry in contents['entries']:
i += 1
if entry['status'] == 0:
no_task_left = False
if no_task_left:
chalk.green(
'All tasks have been competed! Add a new task by entering "yoda diary nt"'
)
else:
click.echo('Today\'s agenda:')
click.echo('----------------')
click.echo("Number | Time | Task")
click.echo("-------|---------|-----")
i = 0
for entry in contents['entries']:
i += 1
time = entry['time']
text = entry['text'] if entry['status'] == 0 else strike(
entry['text'])
status = "O" if entry['status'] == 0 else "X"
if entry['status'] == 0:
no_task_left = False
click.echo(" " + str(i) + " | " + time + ": " +
text)
while not_valid_task_number:
chalk.blue(
'Enter the task number that you would like to set as completed'
)
task_to_be_completed = int(raw_input())
if (task_to_be_completed > len(contents['entries'])):
chalk.red('Please Enter a valid task number!')
else:
contents['entries'][task_to_be_completed -
1]['status'] = 1
input_data(contents, TODAYS_TASKS_ENTRY_FILE_PATH)
not_valid_task_number = 0
else:
chalk.red(
'There are no tasks for today. Add a new task by entering "yoda diary nt"'
)
def show_status():
success = chalk.green(emoji.emojize(':heavy_check_mark:', use_aliases=True).center(10, " ") * 5)
error = chalk.red(emoji.emojize(':x:', use_aliases=True).center(10, " ") * 5)
if hasattr(F1, '_ts') and hasattr(F1, '_name'):
print(success)
print(chalk.green("¡Escala de tiempo inicializada!"))
# TODO: Imprimir los datos de la escala de tiempo.
# TODO: Emplear una tupla en vez de una lista.
print(f"Datos de la escala de tiempo:")
print(f"Su nombre es {F1._name}.")
print(f'Conjunto T = {{{", ".join(map(str, F1._ts))}}}.')
else:
print(error)
print(chalk.red("Se ha producido un error."))
def main():
"The function to execute when running hx"
options, args = HendrixOptionParser.parse_args(sys.argv[1:])
options = vars(options)
try:
action = args[0]
except IndexError:
HendrixOptionParser.print_help()
return
exposeProject(options)
options = djangoVsWsgi(options)
options = devFriendly(options)
redirect = noiseControl(options)
try:
if action == 'start' and not options['daemonize']:
chalk.eraser()
chalk.blue('Starting Hendrix...')
elif action == 'stop':
chalk.green('Stopping Hendrix...')
if options['daemonize']:
daemonize, _reload, opts = cleanOptions(options)
process = subprocess.Popen(
['hx', action] + opts, stdout=redirect, stderr=redirect
)
time.sleep(2)
if process.poll():
raise RuntimeError
else:
launch(*args, **options)
if action not in ['start_reload', 'restart']:
chalk.eraser()
chalk.green('\nHendrix successfully closed.')
except Exception, e:
msg = (
'ERROR: %s\nCould not %s hendrix. Try again using the --traceback '
'flag for more information.'
)
chalk.red(msg % (str(e), action), pipe=chalk.stderr)
if options['traceback']:
raise
else:
os._exit(1)
async def start(onBind, c):
global config
config = c
import logging
logger = logging.Logger("server")
logger.setLevel(logging.DEBUG)
# Create an app and a runner
app = web.Application()
app.add_routes([web.post("/fromGitlab", fromGitlab)])
app.add_routes([web.post("/fromNest", fromNest)])
runner = web.AppRunner(app, logger=logger)
await runner.setup()
site, port = await start_somewhere(runner)
cur_ip = await get("https://api.ipify.org")
await onBind(f"{cur_ip}:{port}")
print(chalk.green(chalk.bold(" Initialization finished!")))
# Listen for IP changes
while True:
await asyncio.sleep(5)
ip = await get("https://api.ipify.org")
if ip != cur_ip:
print(
chalk.yellow(
f"IP changed from {cur_ip} to {ip}, restarting server..."))
await site.stop()
site, port = await start_somewhere(runner)
cur_ip = ip
await onBind(f"{cur_ip}:{port}")
def outro_alt():
sleep(2)
print(
chalk.yellow('''
██████╗ █████╗ ███╗ ███╗███████╗
██╔════╝ ██╔══██╗████╗ ████║██╔════╝
██║ ███╗███████║██╔████╔██║█████╗
██║ ██║██╔══██║██║╚██╔╝██║██╔══╝
╚██████╔╝██║ ██║██║ ╚═╝ ██║███████╗
╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝
██████╗ ██╗ ██╗███████╗██████╗
██╔═══██╗██║ ██║██╔════╝██╔══██╗
██║ ██║██║ ██║█████╗ ██████╔╝
██║ ██║╚██╗ ██╔╝██╔══╝ ██╔══██╗
╚██████╔╝ ╚████╔╝ ███████╗██║ ██║
╚═════╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝
'''))
s.sound_effect('audio/ending_theme_short.wav')
print(
chalk.yellow('''
...or is it?
'''))
sleep(2)
print(chalk.green("\tWould you like to see the alternate ending? y/n"))
ending = input("> ")
if ending == 'y':
alt()
def from_images(ctx):
args = {
ctx.args[i].strip("--"): ctx.args[i + 1]
for i in range(0, len(ctx.args), 2)
}
try:
source = args.pop("source")
except KeyError:
click.echo(
chalk.red("Source parameter is missing. "
"Use --source to provide the path."))
return
try:
output = args.pop("output")
except KeyError:
click.echo(
chalk.red("Output path is missing. "
"Use --output to provide the path."))
return
images = []
if not os.path.isdir(source):
click.echo(chalk.red("Source should be a directory."))
for filename in os.listdir(source):
if os.path.isfile(os.path.join(source, filename)):
images.append(imageio.imread(os.path.join(source, filename)))
try:
with open(output, "w") as outfile:
imageio.mimsave(outfile, images, format="gif", **args)
click.echo(chalk.green("GIF exported at {}".format(output)))
except (OSError, IOError):
click.echo(
chalk.red("Could not write to file {}. "
"Please check the path".format(output)))
def check_results(self):
print(
f"::set-output name=has_updated_sources::{str(self.has_updated_sources)}"
)
if self.status == "success":
logging.info(
c.green("✅ Successfully linted all files without errors"))
config.delete()
elif self.status == "warning":
logging.warning(
c.yellow(
"◬ Successfully linted all files, but with ignored errors")
)
config.delete()
else:
logging.error(c.red("❌ Error(s) have been found during linting"))
logging.warning(
"To disable linters or customize their checks, you can use a .mega-linter.yml file "
"at the root of your repository")
logging.warning(f"More info at {ML_DOC_URL}/configuration/")
if self.cli is True:
if config.get("DISABLE_ERRORS", "false") == "true":
config.delete()
sys.exit(0)
else:
config.delete()
sys.exit(self.return_code)
config.delete()
async def setHooks(url, host):
project = getUrlRepository(url)
print(f"Setting hooks for {project} at Nest...")
admin = await get(f"https://nest.pijul.com/{project}/admin")
# Parse token
token = (admin.split("""<input type="hidden" name="token" value=""" + "\"",
1)[1].split("\"")[0])
# Delete old hooks
while """<input type="hidden" name="hookid" value=""" + "\"" in admin:
hook_id = (admin.split(
"""<input type="hidden" name="hookid" value=""" + "\"",
1)[1].split("\"")[0])
url, admin = (admin.split(
"""<input style="width:100%" type="text" name="url" value=""" +
"\"", 1)[1].split("\"", 1))
if "fromNest" in url:
await post(f"https://nest.pijul.com/{project}/admin",
data={
"token": token,
"hookid": hook_id,
"hook_action_2": "2",
"action": "delete-hook"
})
# Create hook
await post(f"https://nest.pijul.com/{project}/admin",
data={
"token": token,
"url": f"http://{host}/fromNest",
"secret": "",
"hook_action_2": "2"
})
print(chalk.green(f"Created Nest webhook successfully"))
def shields(self, shield_level):
if shield_level == 100:
return chalk.green(f"Shields: {shield_level}%")
if shield_level > 20:
return chalk.yellow(f"Shields: {shield_level}%")
else:
return chalk.red(f"Shields: {shield_level}%")
def success(self, name: str = "Main Process", output: str = None):
if output is None:
return print(
chalk.red(
f"{time.strftime('%c')} - [{name}]: No output provided!"))
print(chalk.green(f"{time.strftime('%c')} - [{name}]: {output}"))
def move_enemies(world):
# Moving enemies around the board, if chosen direction is empty or hero, action is taken, otherwise they don't mainLoop.
# Build list of enemies first then mainLoop them one at a time
move_tuples = [(1, 0), (0, 1), (-1, 0), (0, -1)]
enemies = world.get_enemies()
for enemy in enemies:
current_location = enemy.get_location()
while True:
choice = random.choice(move_tuples)
next_location = (current_location[0] + choice[0],
current_location[1] + choice[1])
if 0 < next_location[0] <= world.get_rows(
) and 0 < next_location[1] <= world.get_columns():
break
if isinstance(world[next_location], Empty):
world[next_location] = enemy
enemy.update_location(next_location)
world[current_location] = Empty('empty', current_location, True)
elif world[next_location] == hero:
print_image(enemy.get_kind() + '.txt')
print(
chalk.red(
f"Look out! You are being attacked by a {enemy.get_kind()} "
f"armed with a {enemy.get_weapon()}"))
print(chalk.yellow("Here are it's stats..."))
print(chalk.green(enemy))
world[current_location] = battle(enemy)
return
async def syncPijulToGitPatch(branch, git, pijul, action, patch_id, author,
timestamp, message):
small_patch_id = patch_id[:10] + "..."
if action == "add":
print(f" Syncing new patch {small_patch_id}: {message}")
await run(f"cd {pijul}; pijul apply {patch_id} --branch {branch}")
elif action == "remove":
print(f" Reverting patch {small_patch_id}: {message}")
await run(f"cd {pijul}; pijul unrecord {patch_id} --branch {branch}")
await run(f"cd {pijul}; pijul revert --all --branch {branch}")
# Synchronize
await run(f"rsync -rv -f'- .git/' -f'- .pijul/' {pijul}/ {git}/")
# Commit
is_empty = (await run(f"cd {git}; git status --short")).strip() == ""
if action == "add":
message = shlex.quote(
f"{message}\n\nImported from Pijul patch {patch_id}")
elif action == "remove":
message = shlex.quote(f"{message}\n\nReverted Pijul patch {patch_id}")
author = shlex.quote(author)
date = str(timestamp)
await run(
f"cd {git}; git add --all; git commit --author={author} --date='{date}' --message={message} --no-edit --allow-empty"
)
commit = (await run(f"cd {git}; git rev-parse HEAD")).strip()
if is_empty:
print(chalk.yellow(f" No changes (fast-forward), committed {commit}"))
else:
print(chalk.green(f" Done. Committed {commit}"))
def another_trans(account: act) -> None:
chalk.green("""
Would you like another transaction?
=====*=====*=====*=====*=====*=====*=====
Yes: press 1
No: press 2
""")
choose = int(input('Enter ➤➤ '))
if choose == 1:
dep_with(account=account)
else:
chalk.magenta("Thank you! Have a nice day.")
quit()
def responseInColor(request, prefix='Response', opts=None):
"Prints the response info in color"
message = '%s [%s] => Request %s %s %s on pid %d' % (
prefix,
request.code,
str(request.host),
request.method,
request.path,
os.getpid()
)
signal = int(request.code)/100
if signal == 2:
chalk.green(message, opts=opts)
elif signal == 3:
chalk.blue(message, opts=opts)
else:
chalk.red(message, opts=opts)
async def pullGit(url):
# Check whether we have the repo downloaded already
path = urlToPath(url)
if os.path.isdir(path):
print(f" Git: Fetching {url} to {path}...")
await run(f"cd {path}; git fetch")
for r in (await run(f"cd {path}; git branch -r")).split("\n"):
r = r[2:]
if r.startswith("origin/"):
branch = r.split("/", 1)[1]
if not branch.startswith("HEAD -> "):
await run(f"cd {path}; git checkout {branch}")
print(chalk.green(" Done."))
else:
print(f" Git: Cloning {url} to {path}...")
await run(f"cd /tmp; git clone \"{url}\" {path}")
print(chalk.green(" Done."))
def copy_dir_contents(src, dst, ignore=IGNORE):
"Copies all folders and files under src directory to dst"
for f in os.listdir(src):
if f in ignore:
chalk.yellow("Ignoring {0}".format(f))
continue
fpath = os.path.join(src, f)
dst_path = os.path.join(dst, f)
if os.path.isdir(fpath):
if not os.path.exists(dst_path):
os.mkdir(dst_path)
chalk.green("Copying '{0}' and its contents to '{1}'".format(f, dst))
copy_dir_contents(fpath, dst_path, ignore)
else:
chalk.green("Copying file '{0}' to '{1}'".format(f, dst))
shutil.copy(fpath, dst)
def launch(*args, **options):
"""
launch acts on the user specified action and options by executing
Hedrix.run
"""
action = args[0]
if options["reload"]:
event_handler = Reload(options)
observer = Observer()
observer.schedule(event_handler, path=".", recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
pid = os.getpid()
chalk.eraser()
chalk.green("\nHendrix successfully closed.")
os.kill(pid, 15)
observer.join()
exit("\n")
else:
try:
if options["key"] and options["cert"] and options["cache"]:
from hendrix.deploy import hybrid
HendrixDeploy = hybrid.HendrixDeployHybrid
elif options["key"] and options["cert"]:
from hendrix.deploy import ssl
HendrixDeploy = ssl.HendrixDeploySSL
elif options["cache"]:
HendrixDeploy = cache.HendrixDeployCache
else:
HendrixDeploy = base.HendrixDeploy
deploy = HendrixDeploy(action, options)
deploy.run()
except Exception, e:
tb = sys.exc_info()[2]
msg = traceback.format_exc(tb)
chalk.red(msg, pipe=chalk.stderr)
os._exit(1)
def logReload(options):
"""
encompasses all the logic for reloading observer.
"""
event_handler = Reload(options)
observer = Observer()
observer.schedule(event_handler, path='.', recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
pid = os.getpid()
chalk.eraser()
chalk.green('\nHendrix successfully closed.')
os.kill(pid, 15)
observer.join()
exit('\n')
def main():
"The function to execute when running hx"
options, args = HendrixOptionParser.parse_args(sys.argv[1:])
options = vars(options)
try:
action = args[0]
except IndexError:
HendrixOptionParser.print_help()
return
exposeProject(options)
options = djangoVsWsgi(options)
options = devFriendly(options)
redirect = noiseControl(options)
try:
if action == "start" and not options["daemonize"]:
chalk.eraser()
chalk.blue("Starting Hendrix...")
elif action == "stop":
chalk.green("Stopping Hendrix...")
if options["daemonize"]:
daemonize, _reload, opts = cleanOptions(options)
process = subprocess.Popen(["hx", action] + opts, stdout=redirect, stderr=redirect)
time.sleep(2)
if process.poll():
raise RuntimeError
else:
launch(*args, **options)
if action not in ["start_reload", "restart"]:
chalk.eraser()
chalk.green("\nHendrix successfully closed.")
except Exception, Argument:
print Argument
chalk.red("\n Could not %s hendrix.\n" % action, pipe=chalk.stderr)
def main():
"The function to execute when running hx"
options, args = HendrixOptionParser.parse_args(sys.argv[1:])
options = vars(options)
action = args[0]
exposeProject(options)
options = djangoVsWsgi(options)
options = devFriendly(options)
redirect = noiseControl(options)
try:
if action == "start" and not options["daemonize"]:
chalk.eraser()
chalk.blue("Starting Hendrix...")
elif action == "stop":
chalk.green("Stopping Hendrix...")
if options["daemonize"]:
daemonize, _reload, opts = cleanOptions(options)
process = subprocess.Popen(["hx", action] + opts, stdout=redirect, stderr=redirect)
time.sleep(2)
if process.poll():
raise RuntimeError
else:
launch(*args, **options)
if action not in ["start_reload", "restart"]:
chalk.eraser()
chalk.green("\nHendrix successfully closed.")
except Exception, e:
msg = "ERROR: %s\nCould not %s hendrix. Try again using the --traceback " "flag for more information."
chalk.red(msg % (str(e), action), pipe=chalk.stderr)
if options["traceback"]:
raise
else:
os._exit(1)
def lidard(config, name, serial, baud, bind, port, modules, verbose):
'''`lidard` is a RPLidar data-serving daemon.'''
if config is None:
if not serial:
print('A serial path must be specified.')
sys.exit(1)
modules = [m.strip() for m in modules.split(',')]
cfg = {
'serial': serial,
'baud': baud,
'bind': bind,
'port': port,
'modules': modules,
'meta': {
'name': name,
}
}
else:
cfg = read_config(config)
if 'serial' not in cfg:
print('A serial path must be specified in the configuration.')
sys.exit(1)
if 'baud' not in cfg:
cfg['baud'] = baud
if 'port' not in cfg:
cfg['port'] = port
if 'bind' not in cfg:
cfg['bind'] = '0.0.0.0'
if 'modules' not in cfg:
cfg['modules'] = []
if 'meta' in cfg and 'name' not in cfg['meta']:
cfg['meta']['name'] = 'lidard'
ser = _serial.Serial()
ser.port = cfg['serial']
ser.baudrate = cfg['baud']
ser.open()
server = socketserver.UDPServer((cfg['bind'], cfg['port']), LidardServer)
server.config = cfg
server.ser = ser
server.verbose = verbose
# Load the extensions and insert them into the request handler.
ext = {}
for module in cfg['modules']:
chalk.green('loading {}...'.format(module))
# Load and instantiate the extension module
ext[module] = [importlib.import_module(module)]
ext[module].append(ext[module][0].Extension())
server.ext = ext
chalk.green('lidard ready, protocol v2')
@atexit.register
def close():
chalk.blue('shutting down')
server.server_close()
server.serve_forever()
