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'