def guess_and_set_min_level(self) -> "Logger":
"""
Tries to guess the min level from the configuration.
"""
env_vars = ["PYFUNCEBLE_DEBUG_LVL", "PYFUNCEBLE_LOGGING_LVL"]
env_var_helper = EnvironmentVariableHelper()
env_var_found = False
for env_var in env_vars:
if env_var_helper.set_name(env_var).exists():
self.min_level = env_var_helper.get_value()
env_var_found = True
break
if not env_var_found:
if PyFunceble.storage.CONFIGURATION:
# pylint: disable=protected-access
self.min_level = logging._nameToLevel[
PyFunceble.storage.CONFIGURATION.debug.level.upper()
]
else:
self.min_level = self.STD_MIN_LEVEL
def start(self, *, ignore_cli: bool = True) -> "CredentialLoader":
"""
Starts the loading of the credential.
:param ignore_cli:
Ignore questions to end-user.
"""
if not isinstance(self.credential, CredentialBase) and self.authorized:
# We directly share the credential object into the DBSession object.
# This will let us use the DBSession without having to think about
# any other headache.
self.credential = (PyFunceble.cli.factory.DBSession.credential
) = self.DB_TYPE2OBJ[self.db_type]()
env_var_helper = EnvironmentVariableHelper(
env_file_path=self.credential.get_dot_env_file())
for cred_var, env_var in self.credential.VAR2ENV.items():
if env_var_helper.set_name(env_var).exists():
self.set_credential_var(cred_var,
env_var_helper.get_value())
else:
from_file = env_var_helper.get_value_from_env_file()
if from_file:
self.set_credential_var(cred_var, from_file)
elif not ignore_cli:
self.set_credential_var(
cred_var,
self.ask_for_info(
cred_var,
getattr(self.credential,
f"STD_{cred_var.upper()}"),
),
)
else:
self.set_credential_var(
cred_var,
getattr(self.credential,
f"STD_{cred_var.upper()}"),
)
env_var_helper.set_value_in_env_file(
str(getattr(self.credential, cred_var)))
return self
def get_output_directory() -> str: # pragma: no cover ## Not relevant
"""
Provides the location of the output directory.
"""
env_var_helper = EnvironmentVariableHelper()
directory_helper = DirectoryHelper()
if env_var_helper.set_name("PYFUNCEBLE_OUTPUT_LOCATION").exists():
output_directory = env_var_helper.get_value()
else:
output_directory = directory_helper.get_current(with_end_sep=True)
if not output_directory.endswith(os.sep):
output_directory += os.sep
return output_directory
def get_config_directory(
*, project_name: str,
project_version: str) -> str: # pragma: no cover ## Not relevant
"""
Provides the location of the configuration directory.
"""
# pylint: disable=too-many-branches
env_var_helper = EnvironmentVariableHelper()
directory_helper = DirectoryHelper()
if env_var_helper.set_name("PYFUNCEBLE_CONFIG_DIR").exists():
config_directory = env_var_helper.get_value()
elif env_var_helper.set_name("PYFUNCEBLE_OUTPUT_DIR").exists():
config_directory = env_var_helper.get_value()
elif (VersionUtility(project_version).is_cloned()
or env_var_helper.set_name("TRAVIS_BUILD_DIR").exists()
or env_var_helper.set_name("CI_PROJECT_DIR").exists()
and env_var_helper.set_name("GITLAB_CI").exists()):
config_directory = directory_helper.get_current(with_end_sep=True)
else:
if PlatformUtility.is_unix():
config_dir_path = os.path.expanduser(os.path.join("~", ".config"))
if directory_helper.set_path(config_dir_path).exists():
config_directory = config_dir_path
elif directory_helper.set_path(os.path.expanduser("~")).exists():
config_directory = directory_helper.join_path(".")
else:
config_directory = directory_helper.get_current(
with_end_sep=True)
elif PlatformUtility.is_windows():
if env_var_helper.set_name("APPDATA").exists():
config_directory = env_var_helper.get_value()
else:
config_directory = directory_helper.get_current(
with_end_sep=True)
else:
config_directory = directory_helper.get_current(with_end_sep=True)
if not config_directory.endswith(os.sep):
config_directory += os.sep
config_directory += project_name + os.sep
if not directory_helper.set_path(config_directory).exists():
directory_helper.create()
if not config_directory.endswith(os.sep):
config_directory += os.sep
return config_directory
class TestEnvironmentVariableHelper(unittest.TestCase):
"""
Tests of our environment variable helper.
"""
def setUp(self) -> None:
"""
Setups everything needed for the tests.
"""
self.helper = EnvironmentVariableHelper()
self.test_name = "PYFUNCEBLE_TESTING"
self.temp_env_file = tempfile.NamedTemporaryFile("w", delete=False)
def tearDown(self) -> None:
"""
Destroys everything needed for the tests.
"""
self.temp_env_file.close()
os.remove(self.temp_env_file.name)
del self.temp_env_file
del self.test_name
del self.helper
def test_set_name_return(self) -> None:
"""
Tests the response from the method which let us set the name to work
with.
"""
actual = self.helper.set_name(self.test_name)
self.assertIsInstance(actual, EnvironmentVariableHelper)
def test_set_name_method(self) -> None:
"""
Tests the method which let us set the name to work with.
"""
given = self.test_name
expected = given
self.helper.set_name(given)
actual = self.helper.name
self.assertEqual(expected, actual)
def test_set_name_attribute(self) -> None:
"""
Tests the method which let us overwrite the `name` attribute.
"""
given = self.test_name
expected = given
self.helper.name = given
actual = self.helper.name
self.assertEqual(expected, actual)
def test_set_name_through_init(self) -> None:
"""
Tests the overwritting of the name to work with through the class
constructor.
"""
given = self.test_name
expected = given
helper = EnvironmentVariableHelper(given)
actual = helper.name
self.assertEqual(expected, actual)
def test_set_env_file_path_return(self) -> None:
"""
Tests the response from the method which let us set the path to the
dot env file to work with.
"""
actual = self.helper.set_env_file_path(self.temp_env_file.name)
self.assertIsInstance(actual, EnvironmentVariableHelper)
def test_set_env_file_path_method(self) -> None:
"""
Tests the method which let us set the path to the dotenv file to work with.
"""
given = self.temp_env_file.name
expected = given
self.helper.set_env_file_path(given)
actual = self.helper.env_file_path
self.assertEqual(expected, actual)
def test_set_env_file_path_attribute(self) -> None:
"""
Tests the method which let us overwrite the `env_file_path` attribute.
"""
given = self.temp_env_file.name
expected = given
self.helper.env_file_path = given
actual = self.helper.env_file_path
self.assertEqual(expected, actual)
def test_set_env_file_path_through_init(self) -> None:
"""
Tests the overwritting of the dotenv file to work with through the class
constructor.
"""
given = self.temp_env_file.name
expected = given
helper = EnvironmentVariableHelper(env_file_path=given)
actual = helper.env_file_path
self.assertEqual(expected, actual)
def test_set_name_not_str(self) -> None:
"""
Tests the method which let us set the name of the environment variable
to work with for the case that the given name is not a string.
"""
given = ["Hello", "World"]
self.assertRaises(TypeError, lambda: self.helper.set_name(given))
def test_set_env_file_path_not_str(self) -> None:
"""
Tests the method which let us set the path to the dotenv file to work
with for the case that the given path is not a string.
"""
given = ["Hello", "World"]
self.assertRaises(TypeError,
lambda: self.helper.set_env_file_path(given))
def test_exists(self) -> None:
"""
Tests of the method which let us test if an environment variable exists.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
os.environ[self.test_name] = "This is a test."
expected = True
actual = self.helper.exists()
self.assertEqual(expected, actual)
del os.environ[self.test_name]
def test_get_value(self) -> None:
"""
Tests of the method which let us get the value of an environment
variable.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
expected = "Hello"
actual = self.helper.get_value(default="Hello")
self.assertEqual(expected, actual)
expected = "This is a test."
os.environ[self.test_name] = "This is a test."
actual = self.helper.get_value(default="Hello")
self.assertEqual(expected, actual)
del os.environ[self.test_name]
def test_get_value_from_file(self) -> None:
"""
Tests of the method which let us get the value of an environment
variable from a given environment file.
"""
self.temp_env_file.write("IS_THIS_A_GHOST=yes\n")
self.temp_env_file.seek(0)
self.helper.set_env_file_path(self.temp_env_file.name)
self.helper.set_name("IS_THIS_A_GHOST")
expected = "yes"
actual = self.helper.get_value_from_env_file()
self.assertEqual(expected, actual)
def test_get_value_from_file_not_found(self) -> None:
"""
Tests of the method which let us get the value of an environment
variable from a given environment file.
In this case, we test the case that the given value is not known.
"""
self.temp_env_file.write("IS_THIS_A_GHOST_NOOOO=yes")
self.temp_env_file.seek(0)
self.helper.set_env_file_path(self.temp_env_file.name)
self.helper.set_name("IS_THIS_A_GHOST")
expected = "hello"
actual = self.helper.get_value_from_env_file(default="hello")
self.assertEqual(expected, actual)
def test_set_value(self) -> None:
"""
Tests of the method which let us set the value of an environment
variable.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
self.helper.set_value("Hello, World!")
expected = "Hello, World!"
actual = self.helper.get_value()
self.assertEqual(expected, actual)
del os.environ[self.test_name]
def test_set_value_in_env_file(self) -> None:
"""
Tests of the method which let us set the value of an environment
variable into a file.
"""
self.helper.set_env_file_path(self.temp_env_file.name)
self.helper.set_name("GHOST_FINDER")
self.assertIsNone(self.helper.get_value())
expected = 'GHOST_FINDER="no"\n'
self.helper.set_value_in_env_file("no")
with open(self.temp_env_file.name, "r",
encoding="utf-8") as file_stream:
self.assertTrue("no" in file_stream.read())
expected = "no"
self.assertEqual(expected, self.helper.get_value())
def test_set_value_not_str(self) -> None:
"""
Tests of the method which let us set the value of an environment
variable for the case that the given value to set is not a string.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
self.assertRaises(TypeError,
lambda: self.helper.set_value(["Hello", "World!"]))
def test_delete(self) -> None:
"""
Tests of the method which let us delete an environment variable.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
self.helper.set_value("Hello, World!")
expected = True
actual = self.helper.exists()
self.assertEqual(expected, actual)
self.helper.delete()
expected = False
actual = self.helper.exists()
self.assertEqual(expected, actual)
def test_delete_value_in_env_file(self) -> None:
"""
Tests of the method which let us delete the value of an environment
variable into a file.
"""
self.temp_env_file.write("GHOST_SPEAKER=yes\n")
self.helper.set_env_file_path(self.temp_env_file.name)
self.helper.set_name("GHOST_SPEAKER")
self.helper.set_value("no")
with open(self.temp_env_file.name, "r",
encoding="utf-8") as file_stream:
self.assertTrue(self.helper.name in x
for x in file_stream.readlines())
self.helper.delete_from_env_file()
with open(self.temp_env_file.name, "r",
encoding="utf-8") as file_stream:
self.assertTrue(self.helper.name not in x
for x in file_stream.readlines())
self.assertIsNone(self.helper.get_value())
from PyFunceble.helpers.merge import Merge
from starlette.middleware.cors import CORSMiddleware
import pyfunceble_webworker.storage
from pyfunceble_webworker import __version__
from pyfunceble_webworker.core.defaults import assets as assets_defaults
from pyfunceble_webworker.core.defaults import pyfunceble as pyfunceble_defaults
from pyfunceble_webworker.core.defaults import routes as routes_defaults
from pyfunceble_webworker.core.settings import core_settings
from pyfunceble_webworker.models.info import CoreLocation
from pyfunceble_webworker.models.links import Links
from pyfunceble_webworker.routes.v1.api import api_router as v1_api_router
env_var_helper = EnvironmentVariableHelper()
if not env_var_helper.set_name("PYFUNCEBLE_WORKERS_DATA_DIR").exists():
raise RuntimeError(
"Could not find PYFUNCEBLE_WORKERS_DATA_DIR environment variable.")
pyfunceble_webworker.storage.CONFIG_DIRECTORY = env_var_helper.get_value()
PyFunceble.storage.CONFIG_DIRECTORY = os.path.join(
pyfunceble_webworker.storage.CONFIG_DIRECTORY,
secrets.token_hex(8),
)
DirectoryHelper(PyFunceble.storage.CONFIG_DIRECTORY).create()
DirectoryHelper(pyfunceble_webworker.storage.CONFIG_DIRECTORY).create()
file_helper = FileHelper()
pyfunceble_config_loader = ConfigLoader()
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
import os
from typing import List, Optional
from PyFunceble.helpers.environment_variable import EnvironmentVariableHelper
env_var = EnvironmentVariableHelper()
DEFAULT_EMAIL: str = "*****@*****.**"
UNDER_CI_ENVS: List[str] = ["GITHUB_ACTIONS"]
UNDER_CI: bool = any(env_var.set_name(x).exists() for x in UNDER_CI_ENVS)
WORKSPACE_DIR: Optional[str] = env_var.set_name("GITHUB_WORKSPACE").get_value(
default=os.getcwd())
GITHUB_TOKEN: Optional[str] = env_var.set_name("GITHUB_TOKEN").get_value(
default=None)
GIT_EMAIL: Optional[str] = env_var.set_name("GIT_EMAIL").get_value(
default=None)
GIT_NAME: str = env_var.set_name("GIT_NAME").get_value(default="dead-hostsbot")
GIT_BRANCH: str = env_var.set_name("GIT_BRANCH").get_value(default="master")
GIT_DISTRIBUTION_BRANCH: str = env_var.set_name(
"GIT_DISTRIBUTION_BRANCH").get_value(default=GIT_BRANCH)