async def asyncautoschedevolution():
if not await asyncgetnexteventinfo():
now = Now(fmt="dt")
while now.strftime("%a") != "Fri":
now += timedelta(1)
enddt = now + timedelta(days=3)
enddate = enddt.date()
startdate = now.date()
einfo = await db.fetchone(
f"SELECT * FROM autoevents WHERE title = 'Evolution Weekend'")
await db.update(
"INSERT INTO events (completed, starttime, endtime, title, description, cfgfilesuffix, announced) VALUES (0, '%s', '%s', '%s', '%s', '%s', False)"
% (
startdate,
enddate,
einfo["title"],
einfo["description"],
einfo["cfgfilesuffix"],
))
log.log(
"EVENTS",
f"Scheduling next Evolution Weekend Event {startdate} - {enddate}")
else:
log.log(
"EVENTS",
f"Skipping auto-schedule of next Evo weekend to do existing next event",
)
def run():
try:
parsed = parse_args(gms)
if parsed._command is None:
gms.parse_args(['-h'])
check_args(parsed)
defaults = default_args(parsed)
args = merge_defaults(defaults, parsed)
if args.get('no_recursion'):
args.max_depth = 0
configure_logging(
args.verbose - args.quiet,
username=args.username,
debug=args.debug,
log_to_stdout=args.log_to_stdout,
log_to_file=args.log_to_file
)
args.func(args)
logger.log('NORMAL', "All done!")
except KeyboardInterrupt:
gms.exit(130, "\nInterrupted by user")
def transfer( self, amount_tao: int, destination: str):
r""" Transfers token of amount to dest.
"""
self.wallet.assert_coldkey()
self.wallet.assert_coldkeypub()
self.subtensor.connect()
transfer_balance = Balance.from_float( amount_tao )
acount_balance = self.subtensor.get_balance(self.wallet.coldkey.ss58_address)
if acount_balance < transfer_balance:
logger.log('USER-CRITICAL', "Not enough balance (\u03C4{}) to transfer \u03C4{}".format(acount_balance, transfer_balance))
quit()
logger.log('USER-ACTION', "Requesting transfer of \u03C4{}, from coldkey: {} to destination: {}".format(transfer_balance.tao, self.wallet.coldkey.public_key, destination))
logger.log('USER-INFO', "Waiting for finalization...")
result = self.subtensor.transfer(
wallet = self.wallet,
dest = destination,
amount = transfer_balance,
wait_for_finalization = True,
timeout = bittensor.__blocktime__ * 5
)
if result:
logger.log('USER-SUCCESS', "Transfer finalized with amount: \u03C4{} to destination: {} from coldkey.pub: {}".format(transfer_balance.tao, destination, self.wallet.coldkey.public_key))
else:
logger.log('USER-CRITICAL', "Transfer failed")
def derivative(self, wrt):
"""
Take the derivative of the expression.
If 0 or 1 variables are present, no need to pass any other argument.
If >1 variables are present the user must specify which variables to
take the derivative for by passing a variable number of string arguments
For more information about derivatives: https://docs.sympy.org/latest/tutorial/calculus.html
Arguments:
wrt: str. Variable number of variables name or ints for derivative order
Returns:
a new Expression representing the derivative.
Raises:
DerivativeArgumentsNumberError if the number of variable >2 and wrt is not specified
"""
logger.log("EXPRESSION", f"{self} - derivative. Wrt: {wrt}")
wrt = wrt or ""
try:
expr = Expression(
str(Derivative(self.expression, *wrt, evaluate=False)))
except ValueError:
raise DerivativeArgumentsNumberError(self, wrt)
return expr
def test_log_str_level(writer):
logger.add(writer,
format="{level.name} -> {level.no} -> {message}",
colorize=False)
logger.log("DEBUG", "test")
assert writer.read() == "DEBUG -> 10 -> test\n"
def get_local_songs(paths,
*,
filters=None,
max_depth=math.inf,
exclude_paths=None,
exclude_regexes=None,
exclude_globs=None):
logger.log('NORMAL', "Loading local songs")
local_songs = [
filepath for filepath in get_filepaths(paths,
max_depth=max_depth,
exclude_paths=exclude_paths,
exclude_regexes=exclude_regexes,
exclude_globs=exclude_globs)
if audio_metadata.determine_format(filepath) in [
audio_metadata.FLAC,
audio_metadata.MP3,
audio_metadata.OggOpus,
audio_metadata.OggVorbis,
audio_metadata.WAVE,
]
]
logger.info("Found {} local songs", len(local_songs))
matched_songs = filter_metadata(local_songs, filters)
return matched_songs
async def asynclinker(inst, whoasked):
steamid = await asyncgetsteamid(whoasked)
player = await db.fetchone(f"SELECT * FROM players WHERE steamid = '{steamid}'")
if player:
if player["discordid"] is None or player["discordid"] == "":
rcode = "".join(str(x) for x in random.sample(range(10), 4))
log.log(
"PLAYER",
f'Generated code [{rcode}] for link request from [{player["playername"].title()}] on [{inst.title()}]',
)
await db.update(
f"""DELETE from linkrequests WHERE steamid = '{player["steamid"]}'"""
)
await db.update(
f"""INSERT INTO linkrequests (steamid, name, reqcode) VALUES ('{player["steamid"]}', '{player["playername"]}', '{str(rcode)}')"""
)
message = f"Your discord link code is {rcode}, goto discord now and type !linkme {rcode}"
await asyncserverchatto(inst, player["steamid"], message)
else:
log.warning(
f'link request for {player["playername"]} denied, already linked'
)
message = f"You already have a discord account linked to this account"
await asyncserverchatto(inst, player["steamid"], message)
else:
log.error(f"User not found in DB {whoasked}!")
return True
def download_songs(mm, songs, template=None):
logger.success(f"Downloading {len(songs)} songs from Google Music")
if not template:
template = Path.cwd()
songnum = 0
total = len(songs)
pad = len(str(total))
for song in songs:
songnum += 1
try:
audio, _ = mm.download(song)
except Exception as e: # TODO: More specific exception.
logger.log(
'FAILURE',
f"({songnum:>{pad}}/{total}) Failed -- {song} | {e}"
)
else:
tags = audio_metadata.loads(audio).tags
filepath = gm_utils.template_to_filepath(template, tags).with_suffix('.mp3')
if filepath.is_file():
filepath.unlink()
filepath.parent.mkdir(parents=True, exist_ok=True)
filepath.touch()
filepath.write_bytes(audio)
logger.success(
f"({songnum:>{pad}}/{total}) Downloaded -- {filepath} ({song['id']})"
)
def router_get(string: str = Query(...,
description="Input string.",
example="string")) -> dict:
"""GET route example. Returns input string in upper case."""
logger.log('LOG ROUTE', "Calling /get route")
return {"example_out": modulo_example.string_upper(string)}
def save_event_log(
event: Events,
target: Optional[Any] = None,
payload: Optional[Dict[str, Any]] = None,
user: Optional[Any] = None,
ip: str = "-",
) -> None:
target_type, target_id = parse_event_target(target)
if payload:
p = json.dumps(obfuscate_dict(payload, max_len=999))
else:
p = ""
log.log(
"EVENT",
"",
event=event,
ip=ip,
user=user.email if user else "-",
target_id=target_id,
target_type=target_type,
payload=p,
)
def demo():
logger.remove()
# logger.add(sys.stdout, level="INFO", colorize=True, format="{time} {level} {message}" )
logger.add(
sys.stdout,
colorize=True,
format=
"<green>{time:YYYY-MM-DD HH:mm:ss}</green>| <level>{message}</level>")
logger.remove()
# logger.add(sys.stdout, colorize=True, format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> <red>|</red> <level>{level: <2}</level> <red>|</red> <cyan>{function}</cyan> <red>-</red> <level>{message}</level>")
logger.add(
sys.stdout,
colorize=True,
format=
"<green>{time:YYYY-MM-DD HH:mm:ss}</green> <red>|</red> <level>{level: <6}</level> <red>|</red> <level>{message}</level>"
)
# logger.add(sys.stdout, colorize=True, format="<green>{time:YYYY-MM-DD HH:mm:ss.}</green> <red>|</red> "
# "<level>{level: <8}</level> <red>|</red> "
# "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>", )
logger.debug("Debug")
logger.info("Info")
logger.error("Error")
new_level = logger.level("SNAKY", no=38, color="<yellow>", icon="🐍")
logger.log("SNAKY", "Here we go!")
pass
async def start():
from unit import __author__, __version__, __namelp__
text = f"""
📘 {__namelp__} LP запущен.
📕 Версия LP: {__version__}
📙 Автор: {__author__}
"""
await user.api.messages.send(peer_id=user_id, message=text, random_id=0)
from loguru import logger as lg
from prefixs import p
from prefixs import stickerforstart, error_stickerforstart
from unit import __version__, __author__
red = lg.level("[LenderLP]", no=38, color="<yellow>")
text = f"""
-----------------
{__namelp__} LP
→ Запуск с параметрами:\n
→ Ваш префикс в LP: {p}
→ Ваши эмодзи: {stickerforstart}, {error_stickerforstart}
→ Версия лп: {__version__}
♔ Автор юзербота: {__author__}
→ Информация получена, LP готово к запуску.
------------------"""
lg.log("[LenderLP]", text)
ellow = lg.level("[LenderLР]", color="<yellow>", no=40)
lg.log("[LenderLР]", "\nИдёт запуск бота!")
def __exit__(self, exc_type, exc_val, exc_tb):
if self.ending:
if self._messages:
logger.log(self._level, ' -> '.join(self._messages))
if exc_val:
logger.error(exc_val)
Logger._messages = None
def test_add_level_then_log_with_int_value(writer):
logger.level("foo", 16)
logger.add(writer, level="foo", format="{level.name} {level.no} {message}", colorize=False)
logger.log(16, "test")
assert writer.read() == "Level 16 16 test\n"
def router_dobro(valor: float = Query(...,
description="Valor para ser dobrado.",
example=2.0)) -> float:
"""A partir de um valor de entrada, retorna seu dobro.
"""
logger.log('LOG ROTA', "Chamada rota /dobro")
return {"valor": modulo_math.dobro(valor)}
def _run_script(
script,
environment: [OrderedDict, dict] = None,
strict_flags=True,
cwd=None,
loglevel="INFO",
stdout=None,
stderr=None,
):
"""Helper for running shell scripts.
:param script: the script to run
:param environment: will be exported at the beginning of the script
:param strict_flags: if True, a prelude is prepended to the script to help catch errors
:param cwd: if not None, the command is executed in the specified path
:param loglevel: log debug informations at this level
:param stdout: passed as the "stdout" parameter to subprocess.run
:param stderr: passed as the "stderr" parameter to subprocess.run
:return: a subprocess.CompletedProcess instance
"""
if strict_flags:
script_to_run = bash_prelude
else:
script_to_run = ""
if environment:
script_to_run += export_environment(environment)
script_to_run += script
logger.log(loglevel, f"The following script is going to be executed:\n" + script.strip())
return subprocess.run(["/bin/bash", "-c", script_to_run], stdout=stdout, stderr=stderr, cwd=cwd)
def get_page(url, proxy=None, options={}):
"""
:Crawling agent
:param url:
:param options:
:return:
"""
base_headers = {
'User-Agent': get_user_agent(),
'Accept-Encoding': 'gzip, deflate, sdch',
'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7'
}
headers = dict(base_headers, **options)
print('Crawling', url)
try:
requests.adapters.DEFAULT_RETRIES = 2 #
response = requests.get(url, headers=headers, proxies=proxy)
logger.log(
'DEBUG',
f' urils - Crawling url: {url} Response : {response.status_code} ')
print('Fetched successfully', url, response.status_code)
if response.status_code == 200:
return response.content
except ConnectionError:
print('Crawl failed', url)
return None
def save_event_log(
event: Events,
target: Optional[Any] = None,
payload: Optional[Dict[str, Any]] = None,
user: Optional[Any] = None,
ip: str = "-",
url: str = "",
) -> None:
"""Save a log entry in security-events.log"""
target_type, target_id = parse_event_target(target)
if payload:
p = orjson.dumps(obfuscate_dict(payload, max_len=999)).decode("UTF8")
else:
p = ""
log.log(
"EVENT",
"",
event=event,
ip=ip,
user=user.email if user else "-",
target_id=target_id,
target_type=target_type,
payload=p,
url=url,
)
async def asyncstartvoter(inst, whoasked):
if globvars.isvoting:
message = "Voting has already started. cast your vote now"
await asyncserverchat(inst, message)
elif await instancestate.check(inst, "maintenance"):
message = "You cannot start a vote during server maintenance"
await asyncserverchat(inst, message)
elif await instancestate.check(inst, "restartwaiting"):
message = "You cannot start a vote while the server is in restart countdown"
await asyncserverchat(inst, message)
elif (
time() - float(await asyncgetlastwipe(inst)) < Secs["4hour"]
): # 4 hours between wipes
rawtimeleft = Secs["4hour"] - (Now() - float(await asyncgetlastwipe(inst)))
timeleft = playedTime(rawtimeleft)
message = f"You must wait {timeleft} until the next wild wipe vote can start"
await asyncserverchat(inst, message)
log.log(
"VOTE",
f"Vote start denied for [{whoasked.title()}] on [{inst.title()}] because 4 hour timer",
)
elif (
Now() - float(await asyncgetlastvote(inst)) < Secs["10min"]
): # 10 min between failed attempts
rawtimeleft = Now() - await asyncgetlastvote(inst)
timeleft = playedTime(rawtimeleft)
message = f"You must wait {timeleft} until the next wild wipe vote can start"
await asyncserverchat(inst, message)
log.log(
"VOTE",
f"Vote start denied for [{whoasked.title()}] on [{inst.title()}] because 10 min timer",
)
else:
globvars.isvoting = True
asyncio.create_task(asyncvoter(inst, whoasked))
async def asyncremoveplayerintribe(tribeid, playername):
tribeidb = await db.fetchone(
f"SELECT tribeid, players, tribename FROM tribes WHERE tribeid = '{tribeid}'"
)
steamid = await db.fetchone(
f"SELECT steamid FROM players WHERE playername = '{playername.lower()}' AND online = True"
)
if tribeidb and steamid:
log.trace(
f"tribeid: {tribeidb[0]}, {len(tribeidb)} players: {type(tribeidb[1])} < {playername}"
)
if isinstance(tribeidb[1], list):
if steamid[0] in tribeidb[1]:
tribeidb[1].remove(steamid[0])
await db.update(
f"UPDATE tribes SET players = ARRAY{tribeidb[1]} WHERE tribeid = '{tribeidb[0]}'"
)
log.log(
"PLAYER",
f"Removing [{playername}] as player in tribe database [{tribeidb[2]}]",
)
else:
log.error(
f"error1 putting player [{playername}] {steamid} in tribe [{tribeid}]"
)
else:
log.error(
f"error2 removing player [{playername}] {steamid} in tribe [{tribeid}]"
)
def __init__(self, expression):
"""
Class representing a mathematical expression.
It takes a string representation of an expression, like:
'3x + log(y) - sqrt 10 + cos pi'
and creates a sympy expression from it.
It can then solve the expression, take derivatives etc..
"""
ExpressionString.__init__(self, str(expression))
# parse and evaluate
if isinstance(expression, str):
self.expression = parse(self.string, evaluate=False)
else:
self.expression = expression
# check if expression is derivative
self.is_derivative = isinstance(self.expression, Derivative)
self.is_eq = isinstance(self.expression, Eq)
logger.log(
"EXPRESSION",
f"\nCreated: {self.unicode} from string {expression}.\nIs derivative: {self.is_derivative}\nIs eq: {self.is_eq}",
)
self.eval()
# get variabls in the expression
self.get_variables()
async def asynclottodeposits(player, inst):
steamid = player["steamid"]
lottocheck = await db.fetchall(
f"""SELECT * FROM lotterydeposits WHERE steamid = '{steamid}'"""
)
if lottocheck and inst.lower() == player["homeserver"].lower():
totallotto = 0
for lotto in lottocheck:
if lotto["givetake"] == 1:
totallotto = totallotto + lotto["points"]
elif lotto["givetake"] == 0:
totallotto = totallotto - lotto["points"]
if totallotto > 0:
scmd = f"tcsar addarctotal {steamid} {int(totallotto)}"
await asyncserverscriptcmd(inst, scmd, wait=True)
log.log(
"POINTS",
f"{totallotto} lottery win points added to [{player[1].title()}]",
)
msg = f'{lotto["points"]} reward points have been deposited into your account for lottery wins!'
await asyncserverchatto(inst, steamid, msg)
elif totallotto < 0:
log.log(
"POINTS",
f"{abs(totallotto)} lottery entry points removed from [{player[1].title()}]",
)
msg = f"{abs(totallotto)} reward points have been withdrawn from your account for a lottery entries"
await asyncserverchatto(inst, steamid, msg)
scmd = f'tcsar setarctotal {steamid} {int(player["rewardpoints"]) - int(abs(totallotto))}'
await asyncserverscriptcmd(inst, scmd, wait=True)
await db.update(f"DELETE FROM lotterydeposits WHERE steamid = '{steamid}'")
def simplify(self):
"""
Simplify the expression, returns a new instance of Expression
For more information about simplification: https://docs.sympy.org/latest/tutorial/simplification.html
"""
logger.log("EXPRESSION", (f"{self} - simplify"))
return Expression(str(simp(self.expression)))
def run_docker_subprocess(self,
args,
stdout=None,
docker_image=None,
docker_genome="/mnt/ref_genome/"):
"""Run docker subprocess as root user, mounting input and reference genome dir"""
ref_genome_dir = os.path.dirname(cnv_pat_settings["genome_fasta_path"])
if not docker_image:
docker_image = self.settings["docker_image"]
docker_command = [
"docker",
"run",
"--rm",
"-v",
f"{ref_genome_dir}/:{docker_genome}:ro",
"-v",
f"{cnv_pat_dir}/input:/mnt/input/:ro",
"-v",
f"{self.bam_mount}:/mnt/bam-input/:ro",
"-v",
f"{cnv_pat_dir}/cnv-caller-resources/:/mnt/cnv-caller-resources/:ro",
"-v",
f"{cnv_pat_dir}/output/:/mnt/output/:rw",
"-v",
f"{cnv_pat_dir}/tests/test_files/:/mnt/test_files/:rw",
docker_image,
*args,
]
logger.log("DOCKER", " ".join(docker_command))
process = subprocess.run(docker_command, check=True, stdout=stdout)
return process
def test_log_int_level(writer):
logger.add(writer,
format="{level.name} -> {level.no} -> {message}",
colorize=False)
logger.log(10, "test")
assert writer.read() == "Level 10 -> 10 -> test\n"
async def get_sequence(checksum: str,
start: int = 0,
end: int = 0,
accept: str = ""):
"""
Return Refget sequence based on checksum value.
str start: Start point of the sequence defined in checksum.
str end: End point of the sequence defined in checksum.
"""
headers = Headers()
params = {"accept": accept}
if start < end:
params["start"] = start
params["end"] = end
url_path = "sequence/" + checksum
try:
result = await create_request_coroutine(
url_list=metadata_url_list(checksum),
url_path=url_path,
headers=headers,
params=params,
)
if result == "":
return HTTPException(status_code=HTTP_404_NOT_FOUND,
detail="Not Found")
return result
except Exception as e:
logger.log("DEBUG", "Unhandled exception in get_sequence " + str(e))
def _extend_cluster(self, cluster):
"""
extend cluster's elements except for missed children
:param cluster:
:return:
"""
result = [element.selector for element in cluster]
for element in cluster:
path_raw = element.path_raw
siblings = list(element.siblings)
for sibling in siblings:
# skip invalid element
if not isinstance(sibling, Element):
continue
sibling_selector = sibling.selector
sibling_path_raw = sibling.path_raw
if sibling_path_raw != path_raw:
continue
# add missed sibling
if sibling_selector not in result:
cluster.append(sibling)
result.append(sibling_selector)
cluster = sorted(cluster, key=lambda x: x.nth)
logger.log('inspect', f'cluster after extend {cluster}')
return cluster
async def view(request):
r = request.json
logger.debug("Getting a list of posts")
if r is None:
return json(general_response("Json not sent in. Please enter it.", {},
title="No JSON"),
status=400)
category = r.get("category")
page = r.get("page")
logger.info("{} {}".format(category, page))
if category is None:
return json(general_response("Page category required", {},
title="No category given"),
status=400)
if (page is None and category != "home"):
return json(general_response("No page number given", {},
title="No Page Number"),
status=400)
logger.log("SNAKY", "Category: {} Page: {}".format(category, page))
# If the category is home, we get all posts. Some information wont be had
# if category == "home":
# all_posts = list(store.query_latest({"type": "post"})) # Put a page limit of 10
# Get stats by post (need to get the stats of each post (votes, author information, etc))
# else:
# post_by_category = list(store.query_latest({"type": "post", "tag": category}, pagination=True, page_num=page, page_size=10))
# Get stats by post (iterate through each)
# Return the information here
all_posts = list(store.query_latest({"type": "post"}))
return json({"msg": "Return a list of post", "data": all_posts})
def test_lazy(writer):
counter = 0
def laziness():
nonlocal counter
counter += 1
return counter
logger.add(writer, level=10, format="{level.no} => {message}")
logger.opt(lazy=True).log(10, "1: {lazy}", lazy=laziness)
logger.opt(lazy=True).log(5, "2: {0}", laziness)
logger.remove()
logger.opt(lazy=True).log(20, "3: {}", laziness)
i = logger.add(writer, level=15, format="{level.no} => {message}")
logger.add(writer, level=20, format="{level.no} => {message}")
logger.log(17, "4: {}", counter)
logger.opt(lazy=True).log(14, "5: {lazy}", lazy=lambda: counter)
logger.remove(i)
logger.opt(lazy=True).log(16, "6: {0}", lambda: counter)
logger.opt(lazy=True).info("7: {}", laziness)
logger.debug("7: {}", counter)
assert writer.read() == "10 => 1: 1\n17 => 4: 1\n20 => 7: 2\n"
def transcode_audio_meta(
self,
input_data: BytesIO,
max_size: int = 7600000,
) -> OutputMeta:
"""
runs transcode_audio, but returns data with metadata.
Args:
input_data (BytesIO): input audio file
max_size (int, optional): Maximum allowed output size, in bytes. Defaults to 7600000.
Returns:
NamedTuple[BytesIO, float, int, int]: (audio_data, encode_elapsed_time_seconds, final_size_size, bitrate_bps)
"""
input_meta = self.input_meta(input_data)
start_time = datetime.now()
audio_out = self.transcode_audio(input_data, max_size)
elapsed = (datetime.now() - start_time).seconds
in_size = input_meta.size
out_size = len(audio_out.getvalue())
transcode_status = True if in_size != out_size else False
logger.log(
"STATS",
f"audio_transcode: elapsed: {elapsed}s, size: {out_size}B.")
return OutputMeta(audio_out, elapsed, out_size, transcode_status)
