def __init__(self):
self.commands = {}
self.variables = Env.load_variables_group(prefix="telegram")
if not self.variables.get("api_key"): # pragma: no cover
raise ServiceUnavailable("Missing API KEY")
self.updater = Updater(
self.variables.get("api_key"),
# Starting from v13 use_context is True by default
# use_context=True,
workers=Env.to_int(self.variables.get("workers"), default=1),
)
# Inline keyboard callback
self.updater.dispatcher.add_handler(
CallbackQueryHandler(self.inline_keyboard_button))
# Errors
self.updater.dispatcher.add_error_handler(self.error_callback)
self.admins = Bot.get_ids(self.variables.get("admins"))
if not self.admins: # pragma: no cover
print_and_exit("No admin list")
self.users = Bot.get_ids(self.variables.get("users"))
self.api = BotApiClient(self.variables)
def get_redis_url(variables: Dict[str, str], protocol: str) -> str:
host = variables.get("host")
port = Env.to_int(variables.get("port"))
pwd = variables.get("password", "")
creds = ""
if pwd:
creds = f":{pwd}@"
return f"{protocol}://{creds}{host}:{port}/0"
def test_env(self, faker: Faker) -> None:
assert not Env.to_bool(None)
assert Env.to_bool(None, True)
assert not Env.to_bool(False)
assert Env.to_bool(True)
assert not Env.to_bool(0)
assert Env.to_bool(1)
assert Env.to_bool(1 + faker.pyint())
assert Env.to_bool(-faker.pyint() - 1)
assert not Env.to_bool("")
assert not Env.to_bool("false")
assert not Env.to_bool("False")
assert not Env.to_bool("FALSE")
assert Env.to_bool("true")
assert Env.to_bool("True")
assert Env.to_bool("TRUE")
assert Env.to_bool(faker.pystr())
assert not Env.to_bool(object)
assert Env.to_bool(object, True)
random_default = faker.pyint()
assert Env.to_int(None) == 0
assert Env.to_int(None, random_default) == random_default
assert Env.to_int(random_default) == random_default
assert Env.to_int("42") == 42
assert Env.to_int("-42") == -42
assert Env.to_int(str(random_default)) == random_default
assert Env.to_int(faker.pystr()) == 0
assert Env.to_int(faker.pystr(), random_default) == random_default
assert Env.to_bool(object) == 0
prefix = faker.pystr().lower()
var1 = faker.pystr()
var2 = faker.pystr().lower()
var3 = faker.pystr().upper()
val1 = faker.pystr()
val2 = faker.pystr()
val3 = faker.pystr()
os.environ[f"{prefix}_{var1}"] = val1
os.environ[f"{prefix}_{var2}"] = val2
os.environ[f"{prefix}_{var3}"] = val3
variables = Env.load_variables_group(prefix)
assert variables is not None
assert isinstance(variables, dict)
assert len(variables) == 3
assert var2 in variables
assert var3 not in variables
assert var3.lower() in variables
assert variables.get(var1.lower()) == val1
assert variables.get(var2.lower()) == val2
assert variables.get(var3.lower()) == val3
def get_mongodb_url(variables: Dict[str, str], protocol: str) -> str:
host = variables.get("host")
port = Env.to_int(variables.get("port"))
user = variables.get("user", "")
pwd = variables.get("password", "")
creds = ""
if user and pwd:
creds = f"{user}:{pwd}@"
return f"{protocol}://{creds}{host}:{port}"
def connect(self, **kwargs: str) -> "RedisExt":
variables = self.variables.copy()
variables.update(kwargs)
# ssl=True, ssl_ca_certs=certifi.where()
# turning off hostname verification (not recommended):
# ssl_cert_reqs=None
# Please note about the huge drop of performances with TLS:
# https://github.com/redis/redis/issues/7595
self.r = StrictRedis(
host=variables.get("host", "redis.dockerized.io"),
port=Env.to_int(variables.get("port"), 6379),
password=variables.get("password"),
db=RedisExt.DB,
)
return self
def connect(self, **kwargs):
variables = self.variables.copy()
variables.update(kwargs)
# ssl=True, ssl_ca_certs=certifi.where()
# turning off hostname verification (not recommended):
# ssl_cert_reqs=None
# Please note about the huge drop of performances with TLS:
# https://github.com/redis/redis/issues/7595
self.r = StrictRedis(
host=variables.get("host", "redis.dockerized.io"),
port=Env.to_int(variables.get("port"), 6379),
password=variables.get("password"),
# Usually 0 is used by celery
# 1 by celery-beat
# 2 by flask caching
# We use use here 3? Or keep 0 and shift the others?
db=0,
)
return self
def connect(self, **kwargs: str) -> "Mail":
self.instance_variables.update(kwargs)
port = Env.to_int(self.instance_variables.get("port")) or 25
host = self.instance_variables.get("host")
if port == 465:
smtp = SMTP_SSL(host)
else:
smtp = SMTP(host)
smtp.set_debuglevel(0)
log.debug("Connecting to {}:{}", host, port)
smtp.connect(host, port)
smtp.ehlo()
username = self.instance_variables.get("username")
password = self.instance_variables.get("password")
if username and password:
smtp.login(username, password)
self.smtp = smtp
return self
def get_instance(
self: T,
verification: Optional[int] = None,
expiration: Optional[int] = None,
**kwargs: str,
) -> T:
if not Connector.check_availability(self.name):
raise ServiceUnavailable(f"Service {self.name} is not available")
if verification is None:
# this should be the default value for this connector
verification = Env.to_int(self.variables.get("verification_time"))
if expiration is None:
# this should be the default value for this connector
expiration = Env.to_int(self.variables.get("expiration_time"))
# When context is empty this is a connection at loading time
# Do not save it
if stack.top is None:
log.debug("First connection for {}", self.name)
# can raise ServiceUnavailable exception
obj = self.initialize_connection(expiration, verification, **kwargs)
return obj
unique_hash = str(sorted(kwargs.items()))
obj = self.get_object(name=self.name, key=unique_hash)
# if an expiration time is set, verify the instance age
if obj and obj.connection_expiration_time:
# the instance is invalidated if older than the expiration time
if datetime.now() >= obj.connection_expiration_time:
log.info("{} connection is expired", self.name)
obj.disconnect()
obj = None
# If a verification time is set, verify the instance age
if obj and obj.connection_verification_time:
now = datetime.now()
# the instance is verified if older than the verification time
if now >= obj.connection_verification_time:
# if the connection is still valid, set a new verification time
if obj.is_connected():
# Set the new verification time
ver = timedelta(seconds=verification)
obj.connection_verification_time = now + ver
# if the connection is no longer valid, invalidate the instance
else: # pragma: no cover
log.info(
"{} is no longer connected, connector invalidated", self.name
)
obj.disconnected = True
# return the instance only if still connected
# (and not invalidated by the verification check)
if obj and not obj.disconnected:
return obj
# can raise ServiceUnavailable exception
obj = self.initialize_connection(expiration, verification, **kwargs)
self.set_object(name=self.name, obj=obj, key=unique_hash)
return obj
def connect(self, **kwargs):
self.instance_variables.update(kwargs)
if port := self.instance_variables.get("port"):
port = Env.to_int(port)