class FlaskConfig: # pylint: disable=R0903
"""Flask specific configuration."""
SECRET_KEY = environ.var(_gen_secret_key())
DEBUG = environ.bool_var(False)
TESTING = environ.bool_var(False)
SQLALCHEMY_DATABASE_URI = environ.var("sqlite://")
SQLALCHEMY_TRACK_MODIFICATIONS = environ.bool_var(False)
class Child(object):
var7 = environ.var(help="var7, no default")
var8 = environ.var("bar", help="var8, has default")
var9 = environ.bool_var(help="var9, bool_var, no default")
var10 = environ.bool_var(True, help="var10, bool_var, has default")
var11 = environ.var("canine",
name="DOG2",
help="var11, named, has default")
var12 = environ.var(name="CAT2", help="var12, named, no default")
var13 = environ.var("default") # var with default, no help
var14 = environ.var() # var without default, no help
class Email:
host = environ.var(
default='mxf9a9.netcup.net',
converter=str,
help="The SMTP Hostname to use to send emails through."
)
port = environ.var(
default=587,
converter=int,
help="The SMTP Port to use to send emails through."
)
tls = environ.bool_var(
default=True,
help="SMTP use TLS or not.")
timeout = environ.var(
default=60,
converter=int,
help="The Default Timeout for SMTP Connection establishment."
)
backend = environ.var(
default='django.core.mail.backends.smtp.EmailBackend',
converter=str,
help="The EMAIL Backend to use for django."
)
user = environ.group(User)
class Email:
class Backend(enum.Enum):
CONSOLE = "console"
SMTP = "smtp"
_PARAM_HELP = "Required for SMTP only"
def _convert_backend(value):
backend = NoeConfig.Email.Backend(value)
return f"django.core.mail.backends.{backend.value}.EmailBackend"
def _validate_param(obj, attribute, value):
if not value and obj.backend == "smtp":
raise ValueError(
f"The DJANGO_DATABASE_{attribute.name.upper()} environment variable is required\n{attribute!r}"
)
def _convert_verification_key(value):
if value is None:
raise ValueError("You need to generate an EMAIL_VERIFICATION_KEY.")
value_bytes = value.encode()
try:
Fernet(value_bytes)
except Exception as exc:
raise ValueError(f"EMAIL_VERIFICATION_KEY: {value}")
else:
return value_bytes
backend = environ.var(converter=_convert_backend, help='"console" or "smtp"')
host = environ.var(default=None, help=_PARAM_HELP)
port = environ.var(default=None, help=_PARAM_HELP)
user = environ.var(default=None, help=_PARAM_HELP)
password = environ.var(default=None, help=_PARAM_HELP)
use_tls = environ.bool_var(default=True)
default_from = environ.bool_var(help="Sender email address for automatic emails")
verification_key = environ.var(
default=None,
converter=_convert_verification_key,
help="SECRET_KEY for encrpyting the email verification token",
)
class Parent(object):
not_a_var = attr.ib() # For testing that only environ.var's are processed.
var1 = environ.var(help="var1, no default")
var2 = environ.var("bar", help="var2, has default")
var3 = environ.bool_var(help="var3, bool_var, no default")
var4 = environ.bool_var(True, help="var4, bool_var, has default")
var5 = environ.var("canine", name="DOG", help="var5, named, has default")
var6 = environ.var(name="CAT", help="var6, named, no default")
@environ.config
class Child(object):
var7 = environ.var(help="var7, no default")
var8 = environ.var("bar", help="var8, has default")
var9 = environ.bool_var(help="var9, bool_var, no default")
var10 = environ.bool_var(True, help="var10, bool_var, has default")
var11 = environ.var("canine",
name="DOG2",
help="var11, named, has default")
var12 = environ.var(name="CAT2", help="var12, named, no default")
var13 = environ.var("default") # var with default, no help
var14 = environ.var() # var without default, no help
child = environ.group(Child)
class RuntimeConfig: # pylint: disable=too-few-public-methods
"""Config of runtime env."""
debug = environ.bool_var(False, name='DEBUG')
env = environ.var(
'prod',
name='ENV',
validator=attr.validators.in_(('dev', 'prod')),
)
mode = environ.var(
'auto',
name='OCTOMACHINERY_APP_MODE',
converter=lambda val: detect_env_mode() if val == 'auto' else val,
validator=attr.validators.in_(('app', 'action')),
)
class Configuration: # pylint: disable=R0903
"""Root configuration."""
@environ.config
class FlaskConfig: # pylint: disable=R0903
"""Flask specific configuration."""
SECRET_KEY = environ.var(_gen_secret_key())
DEBUG = environ.bool_var(False)
TESTING = environ.bool_var(False)
SQLALCHEMY_DATABASE_URI = environ.var("sqlite://")
SQLALCHEMY_TRACK_MODIFICATIONS = environ.bool_var(False)
flask = environ.group(FlaskConfig)
skip_db_setup = environ.bool_var(False)
verbosity = environ.var(
"WARNING",
validator=in_(["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]))
class RuntimeConfig:
"""Config of runtime env."""
debug = environ.bool_var(False, name='DEBUG')
env = environ.var(
'prod',
name='ENV',
validator=attr.validators.in_(('dev', 'prod')),
)
mode = environ.var(
'auto',
name='OCTOMACHINERY_APP_MODE',
converter=lambda val: detect_env_mode() if val == 'auto' else val,
validator=attr.validators.in_(('app', 'action')),
)
app_name = environ.var(None, name='OCTOMACHINERY_APP_NAME')
app_version = environ.var(None, name='OCTOMACHINERY_APP_VERSION')
app_url = environ.var(None, name='OCTOMACHINERY_APP_URL')
class Config:
"""Custom Config class."""
allowed_hosts = environ.var("*", converter=csv_converter)
db_url = environ.var(
"sqlite:///db.sqlite3") # default allows for running manage.py locally
debug = environ.bool_var(False)
django_env = environ.var("local")
secret_key = environ.var("default-secret-key")
@environ.config
class RestFramework:
parser_classes = environ.var("rest_framework.parsers.JSONParser",
converter=csv_converter)
renderer_classes = environ.var(
"rest_framework.renderers.JSONRenderer",
converter=csv_converter,
)
drf: RestFramework = environ.group(RestFramework)
class WichtelitConfig:
secret_key = environ.var(
default='---cjz#uz(&br66^fis#p+(x1!wpqt&%nr#ny_!@-09#*jwk+m',
converter=str,
help="The Secret Key of the Django Application. (Default is development Key," +
" https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/"
)
debug = environ.bool_var(
default=True,
help="This enables the development mode."
)
fqdn = environ.var(
default="wichtelit",
converter=str,
help="Adding the Allowed host from outside."
)
captcha = environ.group(Captcha)
database = environ.group(Database)
email = environ.group(Email)
contact = environ.group(Contact)
class Config:
# default all supported values to None
AWS_REQUIRE_SECRETS = environ.bool_var(
True,
help=('Are AWS credentials required?'
' Set to False if using AWS roles or ~/.aws/credentials.'))
AWS_ACCESS_KEY_ID = environ.var(None)
AWS_SECRET_ACCESS_KEY = environ.var(None)
AWS_REGION = environ.var(None)
# we could do
# @environ.config
# class DB
# here, but from the user perspective it doesn't matter
# and not having a nested class makes requirement checking
# simpler in resources.py
ODBC_UID = environ.var(None, help='UID value for odbc_connect query parameter.')
ODBC_PWD = environ.var(None, help='PWD value for odbc_connect query parameter.')
ODBC_DSN = environ.var(None, help='DSN value for odbc_connect query parameter.')
ODBC_SERVER = environ.var(None, help='Server value for odbc_connect query parameter.')
ODBC_PORT = environ.var(None, help='Port value for odbc_connect query parameter.')
ODBC_DRIVER = environ.var(None, help='The ODBC connection driver, e.g. "{ODBC Driver 17 for SQL Server}"')
ODBC_FLAVOR = environ.var('mssql', help='The SQL flavor, or dialect.')
ODBC_CONNECT_PARAMS = environ.var('SERVER,PORT,DRIVER,UID,PWD', converter=_odbc_connect_params)
_connect_string = '{flavor}+pyodbc:///?odbc_connect={odbc_connect}'
@property
def ODBC_CONNECT_URL(self):
odbc_connect = ';'.join(
'%s=%s' % (k.replace('ODBC_', ''), getattr(self, k))
for k in self.ODBC_CONNECT_PARAMS)
connect_url = self._connect_string.format(
flavor=self.ODBC_FLAVOR,
odbc_connect=urllib.parse.quote_plus(odbc_connect)
)
return connect_url
class Config:
GC_CREDENTIALS: str = environ.var() # Path to Google JSON credentials
GC_PROJECT: str = environ.var()
BQ_PYPI_DOWNLOADS_TABLE: str = environ.var("the-psf.pypi.downloads*")
CACHE_RESULTS: bool = environ.bool_var(True)
CACHED_RESULTS_PATH: str = environ.var(CACHE_PATH /
"cached_bq_results.json")
LOGGING_LEVEL: str = environ.var("INFO")
@property
def LOGGING(self):
return {
"version": 1,
"formatters": {
"default": {
"format":
"[%(asctime)s][%(name)s][%(levelname)s]: %(message)s",
"datefmt": "%Y-%m-%d %H:%M:%S",
}
},
"handlers": {
"console": {
"class": "logging.StreamHandler",
"level": self.LOGGING_LEVEL,
"formatter": "default",
}
},
"loggers": {
"": {
"handlers": ["console"],
"level": self.LOGGING_LEVEL,
"propagate": True,
}
},
}
class NoeConfig:
debug = environ.bool_var(
default=False, name="DJANGO_DEBUG", help="SECURITY WARNING: Don't run with debug turned on in production!"
)
secret_key = environ.var(help="SECURITY WARNING: keep the secret key used in production secret!")
frontend_url = environ.var(help="Where the React frontend SPA is hosted")
backend_url = environ.var(help="Where the Django backend is hosted")
allowed_hosts = environ.var(default="*", converter=split_by_comma)
allowed_cors_hosts = environ.var(default=None, converter=lambda val: split_by_comma(val) if val else None)
behind_tls_proxy = environ.bool_var(
default=False,
help='Whether or not to set the "X-Forwarded-Proto" header to "https". Should be set to True behind a proxy.',
)
language_code = environ.var(default="hu-hu")
time_zone = environ.var(default="Europe/Budapest")
log_level = environ.var(default="INFO", help="Python logger log level")
sentry_dsn_url = environ.var(
default=None, name="SENTRY_DSN_URL", help="If you want to track exceptions with https://sentry.io",
)
@environ.config
class Database:
_DB_SQLITE_ENGINE = "django.db.backends.sqlite3"
_PARAM_HELP = "Not required for SQLite"
def _convert_database_engine(value):
if value == "postgresql":
return "django.db.backends.postgresql"
elif value in ("mysql", "mariadb"):
return "django.db.backends.mysql"
elif value in ("sqlite", "sqlite3"):
return NoeConfig.Database._DB_SQLITE_ENGINE
raise ValueError(
f'Invalid database engine: {value!r}\npossible values: "postgresql", "mysql", "mariadb", "sqlite"'
)
def _validate_param(obj, attribute, value):
if not value and obj.engine != NoeConfig.Database._DB_SQLITE_ENGINE:
raise ValueError(
f"The DJANGO_DATABASE_{attribute.name.upper()} environment variable is required\n{attribute!r}"
)
engine = environ.var(converter=_convert_database_engine)
name = environ.var()
user = environ.var(default=None, validator=_validate_param, help=_PARAM_HELP)
password = environ.var(default=None, validator=_validate_param, help=_PARAM_HELP)
host = environ.var(default=None, validator=_validate_param, help=_PARAM_HELP)
port = environ.var(default=None, validator=_validate_param, help=_PARAM_HELP)
database = environ.group(Database)
@environ.config
class Email:
class Backend(enum.Enum):
CONSOLE = "console"
SMTP = "smtp"
_PARAM_HELP = "Required for SMTP only"
def _convert_backend(value):
backend = NoeConfig.Email.Backend(value)
return f"django.core.mail.backends.{backend.value}.EmailBackend"
def _validate_param(obj, attribute, value):
if not value and obj.backend == "smtp":
raise ValueError(
f"The DJANGO_DATABASE_{attribute.name.upper()} environment variable is required\n{attribute!r}"
)
def _convert_verification_key(value):
if value is None:
raise ValueError("You need to generate an EMAIL_VERIFICATION_KEY.")
value_bytes = value.encode()
try:
Fernet(value_bytes)
except Exception as exc:
raise ValueError(f"EMAIL_VERIFICATION_KEY: {value}")
else:
return value_bytes
backend = environ.var(converter=_convert_backend, help='"console" or "smtp"')
host = environ.var(default=None, help=_PARAM_HELP)
port = environ.var(default=None, help=_PARAM_HELP)
user = environ.var(default=None, help=_PARAM_HELP)
password = environ.var(default=None, help=_PARAM_HELP)
use_tls = environ.bool_var(default=True)
default_from = environ.bool_var(help="Sender email address for automatic emails")
verification_key = environ.var(
default=None,
converter=_convert_verification_key,
help="SECRET_KEY for encrpyting the email verification token",
)
email = environ.group(Email)
@environ.config
class Static:
url = environ.var(
default="/static/",
help=(
"URL path generated for static files. "
"If you change this, backend won't serve static files with WhiteNoise anymore."
),
)
root = environ.var(
default="/project_noe/static_root",
help=(
"Where manage.py collectstatic put all static files. "
"The default value is where the static files are in the Docker container"
),
)
static = environ.group(Static)
default_time_slot_capacity = environ.var(default=30, converter=int)
@environ.config
class Szamlazzhu:
agent_key = environ.var()
invoice_prefix = environ.var()
szamlazzhu = environ.group(Szamlazzhu)
@environ.config
class SimplePay:
class Environment(enum.Enum):
SANDBOX = "sandbox"
LIVE = "live"
merchant = environ.var()
secret_key = environ.var()
ipn_url = environ.var()
use_live = environ.var(default=False)
environment = environ.var(name="SIMPLEPAY_ENVIRONMENT", converter=Environment)
def __attrs_post_init__(self):
self.use_live = self.environment is NoeConfig.SimplePay.Environment.LIVE
simplepay = environ.group(SimplePay)
def __attrs_post_init__(self):
if not self.allowed_cors_hosts and "*" not in self.allowed_hosts:
self.allowed_cors_hosts = self.allowed_hosts
class Cfg(object):
t = environ.bool_var()
f = environ.bool_var()
d = environ.bool_var(True)
class SIPAMConfig:
port = environ.var(converter=int,
default=8000,
help="the port the APP listens on.")
env = environ.var(converter=Env,
default=Env.PROD,
help="The environment the APP runs in.")
secret_key = environ.var(
default='#ar^t6d7k&nnvi7$&8g#9plu^6c)9qzg%-k+dtjrcxu7d(z6*_',
converter=str,
help=
("The Secret Key of the Django Application. (Default is development Key,"
" https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/"))
debug = environ.bool_var(default=False,
help="This enables the development mode.")
fqdn = environ.var(default="sipam",
converter=str,
help="Adding the Allowed host from outside.")
log_level = environ.var(default='INFO',
converter=str,
help="Log Level of the application.")
@environ.config
class OIDC:
endpoint = environ.var(
default="https://samples.auth0.com/",
converter=str,
help="This defines the endpoint of the OIDC provider")
client_id = environ.var(
default='sipam',
converter=str,
help=
"This defines the allowed azp definition == client_id in keycloak."
)
allowed_groups = environ.var(
default='',
converter=list_converter,
help="This defines allowed values in the groups_claim")
groups_claim = environ.var(
default='aks',
converter=str,
help="This defines the key for the claim to use for groups.")
bearer_auth_header_prefix = environ.var(
default='OPENID',
converter=str,
help=
"This defines the Authorization Header prefix to look for when using OIDC."
)
@environ.config
class Database:
host = environ.var(default='postgres',
converter=str,
help="The RDBMS Hostname to use to connect to.")
port = environ.var(default=5432,
converter=int,
help="The RDBMS Port to use to connect to.")
name = environ.var(
default='sipam',
converter=str,
help="The Name of the RDBMS Database to use to connect to.")
user = environ.group(User)
oidc = environ.group(OIDC)
database = environ.group(Database)
