def test_config(tmpdir, monkeypatch):
path = os.path.join(tmpdir, ".env")
with open(path, "w") as file:
file.write("# Do not commit to source control\n")
file.write("DATABASE_URL=postgres://user:pass@localhost/dbname\n")
file.write("REQUEST_HOSTNAME=example.com\n")
file.write("SECRET_KEY=12345\n")
file.write("BOOL_AS_INT=0\n")
file.write("\n")
file.write("\n")
config = Config(path, environ={"DEBUG": "true"})
def cast_to_int(v) -> int:
return int(v)
DEBUG = config("DEBUG", cast=bool)
DATABASE_URL = config("DATABASE_URL", cast=URL)
REQUEST_TIMEOUT = config("REQUEST_TIMEOUT", cast=int, default=10)
REQUEST_HOSTNAME = config("REQUEST_HOSTNAME")
SECRET_KEY = config("SECRET_KEY", cast=Secret)
assert config("BOOL_AS_INT", cast=bool) is False
assert config("BOOL_AS_INT", cast=cast_to_int) == 0
assert config("DEFAULTED_BOOL", cast=cast_to_int, default=True) == 1
assert DEBUG is True
assert DATABASE_URL.path == "/dbname"
assert DATABASE_URL.password == "pass"
assert DATABASE_URL.username == "user"
assert REQUEST_TIMEOUT == 10
assert REQUEST_HOSTNAME == "example.com"
assert repr(SECRET_KEY) == "Secret('**********')"
assert str(SECRET_KEY) == "12345"
with pytest.raises(KeyError):
config.get("MISSING")
with pytest.raises(ValueError):
config.get("DEBUG", cast=int)
with pytest.raises(ValueError):
config.get("REQUEST_HOSTNAME", cast=bool)
config = Config(Path(path))
REQUEST_HOSTNAME = config("REQUEST_HOSTNAME")
assert REQUEST_HOSTNAME == "example.com"
config = Config()
monkeypatch.setenv("STARLETTE_EXAMPLE_TEST", "123")
monkeypatch.setenv("BOOL_AS_INT", "1")
assert config.get("STARLETTE_EXAMPLE_TEST", cast=int) == 123
assert config.get("BOOL_AS_INT", cast=bool) is True
monkeypatch.setenv("BOOL_AS_INT", "2")
with pytest.raises(ValueError):
config.get("BOOL_AS_INT", cast=bool)
def event_loop(request):
cfg = Config(".env")
db_url = cfg.get("TEST_DB_URL", default="sqlite://:memory:")
loop = asyncio.get_event_loop()
initializer(["bnstats.models"],
db_url=db_url,
app_label="models",
loop=loop)
yield loop
finalizer()
loop.close()
def test_config(tmpdir):
path = os.path.join(tmpdir, ".env")
with open(path, "w") as file:
file.write("# Do not commit to source control\n")
file.write(
"DATABASE_URL=postgres://username:password@localhost/database_name\n"
)
file.write("REQUEST_HOSTNAME=example.com\n")
file.write("SECRET_KEY=12345\n")
file.write("\n")
file.write("\n")
config = Config(path, environ={"DEBUG": "true"})
DEBUG = config("DEBUG", cast=bool)
DATABASE_URL = config("DATABASE_URL", cast=URL)
REQUEST_TIMEOUT = config("REQUEST_TIMEOUT", cast=int, default=10)
REQUEST_HOSTNAME = config("REQUEST_HOSTNAME")
SECRET_KEY = config("SECRET_KEY", cast=Secret)
assert DEBUG is True
assert DATABASE_URL.path == "/database_name"
assert REQUEST_TIMEOUT == 10
assert REQUEST_HOSTNAME == "example.com"
assert repr(SECRET_KEY) == "Secret('**********')"
assert str(SECRET_KEY) == "12345"
with pytest.raises(KeyError):
config.get("MISSING")
with pytest.raises(ValueError):
config.get("DEBUG", cast=int)
with pytest.raises(ValueError):
config.get("REQUEST_HOSTNAME", cast=bool)
os.environ["STARLETTE_EXAMPLE_TEST"] = "123"
config = Config()
assert config.get("STARLETTE_EXAMPLE_TEST", cast=int) == 123
import databases
from starlette.config import Config
from starlette.datastructures import Secret
config = Config(".config")
DATABASE_URL = config("DATABASE_URL", cast=databases.DatabaseURL)
DEBUG = config.get("DEBUG", cast=bool, default=False)
SECRET_KEY = config("SECRET_KEY", cast=Secret)
from os import environ
from pathlib import Path
from starlette.config import Config
__config = Config(environ.get("SIMPLEPODCAST_CONFIG", ".env"))
UPLOAD_DIR: Path = __config.get("UPLOAD_DIR", Path, "data/uploads")
SQLALCHEMY_DATABASE_URL: str = __config.get("SQLALCHEMY_DATABASE_URL", str,
"sqlite:///./data/test.sqlite3")
PUBLIC_URL: str = __config.get("PUBLIC_URL", str, "http://localhost:8000")
from starlette.templating import Jinja2Templates
from auth import get_current_user
from models import TimeTapDto, NoteTapDto, TimeTapStatisticsRequestDto, MedicationTapDto, MedicationDto
from tap_service import fetch_time_taps, fetch_time_tap, fetch_note_taps, \
delete_note_tap, InvalidInputException, add_note_tap, add_time_tap, get_unused_time_tap_blocks_for_day, \
get_medication_views, update_medication_tap, get_unused_medication_tap_blocks_for_day, add_medication
from views import MainTemplateData
templates = Jinja2Templates(directory="templates/")
log = logging.getLogger(__name__)
app = FastAPI()
config = Config(".env")
if config.get("GOOGLE_CLIENT_ID", default=None) is None \
or config.get("GOOGLE_CLIENT_SECRET", default=None) is None \
or config.get("SESSION_SECRET", default=None) is None:
raise Exception(
"Configuration error. GOOGLE_CLIENT_ID or GOOGLE_CLIENT_SECRET or SESSION_SECRET not specified."
)
oauth = OAuth(config)
oauth.register(name='google',
server_metadata_url=
'https://accounts.google.com/.well-known/openid-configuration',
client_kwargs={'scope': 'openid email profile'})
app.add_middleware(SessionMiddleware, secret_key=config.get("SESSION_SECRET"))
@app.get("/")
import logging
from starlette.config import Config
log = logging.getLogger(__name__)
config = Config(".env")
DISPATCH_JWT_AUDIENCE = config("DISPATCH_JWT_AUDIENCE", default=None)
DISPATCH_JWT_EMAIL_OVERRIDE = config("DISPATCH_JWT_EMAIL_OVERRIDE", default=None)
if config.get("DISPATCH_AUTHENTICATION_PROVIDER_SLUG", default="dispatch-auth-provider-basic") == "dispatch-auth-provider-pkce":
if not DISPATCH_JWT_AUDIENCE:
log.warn("No JWT Audience specified. This is required for IdPs like Okta")
if not DISPATCH_JWT_EMAIL_OVERRIDE:
log.warn("No JWT Email Override specified. 'email' is expected in the idtoken.")
import os
from django.conf.global_settings import *
from typing import List
from starlette.config import Config
from pydantic import AnyHttpUrl
from starlette.datastructures import CommaSeparatedStrings
env = Config('.env')
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env.get('SECRET_KEY', str, 'Bruce Wayne is Batman!')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = env.get('DEBUG', bool, True)
# Application definition
INSTALLED_APPS = ['pixel.apps.PixelConfig']
os.environ["DJANGO_ALLOW_ASYNC_UNSAFE"] = "true"
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': env.get('POSTGRES_DB', str, 'fastrack'),
'USER': env.get('POSTGRES_USER', str, 'fastrackuser'),
'PASSWORD': env.get('POSTGRES_PASSWORD', str, 'fastrackpass'),
'HOST': env.get('POSTGRES_HOST', str, 'localhost'),
'PORT': env.get('POSTGRES_PORT', int, 5800),
from authlib.integrations.starlette_client import OAuth
from fastapi.responses import HTMLResponse
from starlette.config import Config
from starlette.middleware.sessions import SessionMiddleware
from loginpass import create_fastapi_routes, Twitter, GitHub, Google
from fastapi import FastAPI
app = FastAPI()
config = Config(".env")
oauth = OAuth(config)
app.add_middleware(SessionMiddleware, secret_key=config.get("SECRET_KEY"))
backends = [Twitter, GitHub, Google]
@app.get("/", response_class=HTMLResponse)
async def root() -> str:
tpl = '<li><a href="/login/{}">{}</a></li>'
lis = [tpl.format(b.NAME, b.NAME) for b in backends]
return "<ul>{}</ul>".format("".join(lis))
def handle_authorize(remote, token, user_info, request):
return user_info
router = create_fastapi_routes(backends, oauth, handle_authorize)
import requests
from starlette.config import Config
from starlette.applications import Starlette
from starlette.middleware.sessions import SessionMiddleware
from starlette.responses import HTMLResponse, RedirectResponse
from authlib.integrations.starlette_client import OAuth
app = Starlette(debug=True)
app.add_middleware(SessionMiddleware, secret_key="super-secret-key")
config = Config('.env')
oauth = OAuth(config)
oauth.register(
name='azure',
server_metadata_url=config.get('WELL_KNOWN_URL'),
client_kwargs={
'scope': 'openid email profile https://graph.microsoft.com/.default',
'response_mode': 'query',
'response_type': 'code',
},
)
@app.route('/')
async def homepage(request):
user = request.session.get('user')
if user:
data = json.dumps(user, indent=4)
userinfo = json.dumps(request.session.get('userinfo'), indent=4)
html = (f'<pre><code>{data}</code></pre>'
import sys
from os import R_OK, access, environ, path
from starlette.config import Config
_config_file = environ.get("MELODIAM_CONFIG", "tests/test.env")
if "--config" in sys.argv:
_config_file = sys.argv[sys.argv.index("--config") + 1]
if not path.exists(_config_file) or not access(_config_file, R_OK):
raise IOError(
f"Config file ({_config_file}) does not exist or not readable")
_config = Config(env_file=_config_file)
DEBUG: bool = _config.get("DEBUG", bool, default=True)
TESTING: bool = _config.get("TESTING", bool, default=False)
API_PREFIX: str = _config.get("API_PREFIX", str, default="/api")
# Secret key for session encryption
SESSION_SECRET: str = _config.get("SESSION_SECRET", str, default="change-me")
# Paths to use for auth API
LOGIN_PATH: str = _config.get("LOGIN_PATH", str, default="/login")
LOGIN_REDIRECT_PATH: str = _config.get("LOGIN_REDIRECT_PATH",
str,
default="/login-redirect")
# Credentials required for Spotify Web API auth
CLIENT_ID: str = _config.get("CLIENT_ID", str)
CLIENT_SECRET: str = _config.get("CLIENT_SECRET", str)
REDIRECT_URI: str = _config.get("REDIRECT_URI", str)
# Timeout for Spotify Web API requests
SPOTIFY_API_TIMEOUT: int = _config.get("SPOTIFY_API_TIMEOUT", int, default=1)
# URL used for PostgreSQL connection
import os
import bugsnag
import uvicorn
from starlette.applications import Starlette
from starlette.config import Config
from starlette.responses import PlainTextResponse
from starlette_bugsnag import BugsnagMiddleware
config = Config('.env')
DEBUG = config.get("DEBUG", default=False)
BUGSNAG_API_KEY = config.get("BUGSNAG_API_KEY", default=None)
bugsnag.configure(api_key=BUGSNAG_API_KEY, project_root=os.getcwd())
app = Starlette(debug=DEBUG)
app.add_middleware(BugsnagMiddleware, debug=DEBUG)
@app.route("/")
def index(request):
return PlainTextResponse("Hello World")
@app.route("/error")
def raiser(request):
raise ValueError("This Is an Error")
if __name__ == "__main__":
"""Settings
Starlette project settings
"""
from starlette.config import Config
# load config from .env file
config = Config('.env')
# expose our settings in this module for use in the application
DEBUG = config.get('DEBUG', cast=bool, default=False)
SECRET = config.get('SECRET', cast=str, default='')
DATABASE_NAME = config('DATABASE_NAME', default='policies_notifications')
if TESTING:
DATABASE_NAME = DATABASE_NAME + '-test'
DB_DSN = config(
"DB_DSN",
cast=make_url,
default=URL(
drivername='postgresql',
username=DATABASE_USER,
password=DATABASE_PASSWORD,
host=DATABASE_HOST,
port=DATABASE_PORT,
database=DATABASE_NAME,
),
)
KAFKA_BOOTSTRAP_SERVERS = config('KAFKA_BOOTSTRAP_SERVERS')
KAFKA_QUEUE_HOOK = config('KAFKA_QUEUE_HOOK')
KAFKA_QUEUE_EMAIL = config('KAFKA_QUEUE_EMAIL')
BOP_URL = config.get('BOP_URL')
BOP_APITOKEN = config('BOP_APITOKEN')
BOP_CLIENT_ID = config('BOP_CLIENT_ID')
BOP_ENV = config('BOP_ENV')
RBAC_URL = config('RBAC_URL')
RBAC_APP_NAME = config('RBAC_APP_NAME')
RBAC_ENDPOINT_URL = '{}/api/rbac/v1/access/?application={}'.format(
RBAC_URL, RBAC_APP_NAME)
X_RH_IDENTITY_HEADER_NAME = 'x-rh-identity'
