from pathlib import Path from starlette.config import Config from app.utils import _TESTING p: Path if _TESTING: p = Path(__file__).parents[2] / ".env.test" else: p = Path(__file__).parents[2] / ".env" config: Config if p.exists(): config = Config(str(p)) else: config = Config() DATABASE_URL: str = config("DATABASE_URL", cast=str, default="postgresql://") COGNITO_POOL_ID: str = config("COGNITO_POOL_ID", cast=str, default="fake-pool-id") COGNITO_REGION: str = config("COGNITO_REGION", cast=str, default="us-west-2") CANDIDATE_AVATAR_PATH: str = "images/candidates/{candidate_id}/{candidate_id}_avatar" AWS_IMG_BUCKET: str = config("AWS_IMG_BUCKET", cast=str, default="fastapi-starter")
import asyncio import os import sys import warnings import aioredis from bitcart import COINS, APIManager from fastapi import HTTPException from notifiers import all_providers, get_notifier from starlette.config import Config from starlette.datastructures import CommaSeparatedStrings from .ext.notifiers import parse_notifier_schema config = Config("conf/.env") # bitcart-related ENABLED_CRYPTOS = config("BITCART_CRYPTOS", cast=CommaSeparatedStrings, default="btc") # redis REDIS_HOST = config("REDIS_HOST", default="redis://localhost") # testing TEST = config("TEST", cast=bool, default="pytest" in sys.modules) # environment DOCKER_ENV = config("IN_DOCKER", cast=bool, default=False) # database
# coding: utf-8 """ 여보세요 Service """ # std lib from logging import getLogger # external lib import feedparser import pypandoc from starlette.config import Config config = Config('.env') # create logger logger = getLogger(__name__) __all__ = ['Service'] class Service: format_from = 'markdown_github' format_to = 'html' def __init__(self): """ init parms """ self.format_to = config('FORMAT_TO', default='html') self.format_from = config('FORMAT_FROM', default='markdown_github')
from starlette.applications import Starlette from starlette.config import Config from starlette.responses import JSONResponse from starlette.routing import Mount, Route, Router from starlette.staticfiles import StaticFiles from starlette.templating import Jinja2Templates # uvicorn import uvicorn from joplin_api import JoplinApi templates = Jinja2Templates(directory="templates") # load configuration settings = Config('.env') main_app = Starlette() main_app.debug = settings('JW_DEBUG') joplin = JoplinApi(token=settings('JOPLIN_WEBCLIPPER_TOKEN')) async def paginator(request, res): """ paginator to limit the flow of the data to render :param request: :param res: :return: """ note_per_page = settings('JW_PAGINATOR', cast=int, default=20)
from starlette.applications import Starlette # UJSON is highly optimized, but does not handle all edge cases. # Fallback to JSON instead of UJSON in case of errors in the jsons. from starlette.responses import UJSONResponse, PlainTextResponse, JSONResponse from starlette.staticfiles import StaticFiles from starlette.config import Config import mysql.connector import json import pathlib config = Config(pathlib.Path(__file__).parent.parent / '.env') HOST = config('DATABASE_URL') PASSWORD = config('SECRET_KEY') app = Starlette() app.debug = config('DEBUG') mydb = mysql.connector.connect(host=HOST, user="******", passwd=PASSWORD, database="Dankbase") mycursor = mydb.cursor() @app.route("/") async def test(request): return PlainTextResponse("Hello world!") @app.route("/json")
def __init__(self, **settings): self.config = Config('.env', settings) self.project_setup() self.apps_setup()
from pathlib import Path from starlette.config import Config from starlette.datastructures import Secret from typing import Optional from fast_microservice.__about__ import __version__ package_root: Path = Path(__file__).parent.parent.parent / ".env" config: Config = Config(package_root if package_root.exists() else None) APP_NAME: str = "Latex docker microservice" APP_VERSION: str = __version__ # Application Root. This is the directory where './app' is in. APP_ROOT: Path = Path(__file__).parents[2] API_PREFIX: str = config("API_PREFIX", cast=str, default="/api") # Very simple Authentication with API KEY API_KEY: Optional[Secret] = config("API_KEY", cast=Secret, default=None) API_AUTHORIZATION_HEADER: str = config( "API_AUTHORIZATION_HEADER", cast=str, default="Token" ) # Set to True to enable debug mode DEBUG: bool = config("DEBUG", cast=bool, default=True) # Sentry error logging SENTRY_ENABLED: bool = config("SENTRY_ENABLED", cast=bool, default=False) SENTRY_DSN: Optional[Secret] = config("SENTRY_DSN", cast=Secret, default=None)
from itsdangerous import Signer from .htmlcomponents import * from .chartcomponents import * from .gridcomponents import * from .quasarcomponents import * from .pandas import * from .routing import Route, SetRoute from .utilities import run_task, create_delayed_task import uvicorn, logging, uuid, sys, os from ssl import PROTOCOL_SSLv23 current_module = sys.modules[__name__] current_dir = os.path.dirname(current_module.__file__) print(f'Module directory: {current_dir}, Application directory: {os.getcwd()}') config = Config('justpy.env') DEBUG = config('DEBUG', cast=bool, default=True) MEMORY_DEBUG = config('MEMORY_DEBUG', cast=bool, default=False) if MEMORY_DEBUG: import psutil LATENCY = config('LATENCY', cast=int, default=0) if LATENCY: print(f'Simulating latency of {LATENCY} ms') SESSIONS = config('SESSIONS', cast=bool, default=True) SESSION_COOKIE_NAME = config('SESSION_COOKIE_NAME', cast=str, default='jp_token') SECRET_KEY = config('SECRET_KEY', default='$$$my_secret_string$$$') # Make sure to change when deployed LOGGING_LEVEL = config('LOGGING_LEVEL', default=logging.WARNING) JustPy.LOGGING_LEVEL = LOGGING_LEVEL UVICORN_LOGGING_LEVEL = config('UVICORN_LOGGING_LEVEL', default='WARNING').lower() COOKIE_MAX_AGE = config('COOKIE_MAX_AGE', cast=int, default=60*60*24*7) # One week in seconds HOST = config('HOST', cast=str, default='127.0.0.1')
import json import uvicorn from fastapi import FastAPI from starlette.config import Config from starlette.requests import Request from starlette.middleware.sessions import SessionMiddleware from starlette.responses import HTMLResponse, RedirectResponse from authlib.integrations.starlette_client import OAuth CONF_URL = 'https://accounts.google.com/.well-known/openid-configuration' CONF_ENVIRONMENT_FILE = '.env' config = Config(CONF_ENVIRONMENT_FILE) oauth = OAuth(config) oauth.register( name = 'google', server_metadata_url=CONF_URL, client_kwargs={ 'scope' : 'openid email profile' } ) app = FastAPI() app.add_middleware(SessionMiddleware, secret_key='12345') @app.route('/') async def homepage(request: Request): user = request.session.get('user') if user: data = json.dumps(user)
Read more at: https://www.starlette.io/config/ """ import pathlib from starlette.config import Config # The application's root and 'instance' directories. Most paths should be # relative to `INSTANCE_DIR`. BASE_DIR = pathlib.Path(__file__).parent.parent.absolute() INSTANCE_DIR = BASE_DIR / "instance" # Config will be read from environment variables and/or '.env' files. config = Config(INSTANCE_DIR / ".env") # Production and Testing modes must be explicitly set if desired. DEBUG = config("DEBUG", cast=bool, default=True) TESTING = config("TESTING", cast=bool, default=False) # SQLite is currently the only supported database. Paths are assumed to be # relative to the application's root directory if configured in '.env'. DATABASE_PATH = config("DATABASE_PATH", cast=str, default=INSTANCE_DIR / "siren.db") # Twilio API configuration. If *ALL* values have not been set, SMS # capabilities are disabled. TWILIO_ACCOUNT_SID = config("TWILIO_ACCOUNT_SID", cast=str, default="") TWILIO_AUTH_TOKEN = config("TWILIO_AUTH_TOKEN", cast=str, default="")
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__":
from pathlib import Path from starlette.config import Config from typing import Tuple BASE_DIR: str = str(Path(__file__).parent) config: Config = Config(f"{BASE_DIR}/.env") DEBUG: bool = config("DEBUG", cast=bool, default=False) ip_info_token: str = config("IP_INFO_TOKEN") ip_info_url: str = config("IP_INFO_URL") organizations: Tuple[str, ...] = ( "AS47764", # mail.ru "AS13238", # yandex.ru ) tg_bot_token: str = config("TG_BOT_TOKEN") tg_bot_url: str = f"https://api.telegram.org/bot{tg_bot_token}" tg_channel_id: int = config("TG_CHANNEL_ID", cast=int)
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" ) == "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." )
from starlette.config import Config from starlette.datastructures import URL, Secret env = Config(".env") DATABASE_URL: URL = env("DATABASE_URL", cast=URL) SECRET_KEY: Secret = env("SECRET_KEY", cast=Secret) TESTING = env('TESTING', cast=bool, default=False)
# ============== Dependency end ============== # # Route methods start @app.get("/", tags=["Doc"]) def main(): return RedirectResponse(url="/docs/") @app.get("/doc2", tags=["Doc"]) def main(): return RedirectResponse(url="/redoc/") # =============== Google auth =============== # config = Config('.env') # read config from .env file 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.get('/login') async def login(request: Request): # absolute url for callback # we will define it below redirect_uri = request.url_for('auth') return await oauth.google.authorize_redirect(request, redirect_uri)
from starlette.config import Config from starlette.datastructures import URL, Secret from starlette.requests import Request from starlette.responses import Response, RedirectResponse, StreamingResponse from starlette.staticfiles import StaticFiles from starlette.templating import Jinja2Templates from commonplace import queries from commonplace.convenience import ( find_dot_env, get_english_dt_description_from_now, icon_class, ) current_dir = Path(__file__).parent config = Config(find_dot_env(current_dir)) debug = config("COMMONPLACE_DEBUG", cast=bool, default=False) db_host = config("EDGEDB_HOST") db_user = config("EDGEDB_USER") db_password = config("EDGEDB_PASSWORD", cast=Secret) db_db = config("EDGEDB_DB", default="commonplace") db_dsn = URL(f"edgedb://{db_user}:{db_password}@{db_host}/{db_db}") db_pool: edgedb.AsyncIOPool templates = Jinja2Templates(directory=str(current_dir / "templates")) logger = logging.getLogger("commonplace.app") logger.setLevel(logging.DEBUG if debug else logging.INFO) app = Starlette(debug=debug) app.mount("/static", StaticFiles(directory=str(current_dir / "static")), name="static")
import logging import sys from typing import List, Optional from loguru import logger from starlette.config import Config from starlette.datastructures import CommaSeparatedStrings, Secret from app.core.logging import InterceptHandler from app.models.pydantic.database import DatabaseURL config = Config() VERSION = '0.0.1' SENTRY_DSN: str = config('SENTRY_DSN', default=None) DEBUG: bool = config("DEBUG", cast=bool, default=False) MAX_CONNECTIONS_COUNT: int = config("MAX_CONNECTIONS_COUNT", cast=int, default=10) MIN_CONNECTIONS_COUNT: int = config("MIN_CONNECTIONS_COUNT", cast=int, default=10) SECRET_KEY: Secret = config("SECRET_KEY", cast=Secret) PROJECT_NAME: str = "Book Graphics" ALLOWED_HOSTS: List[str] = config( "ALLOWED_HOSTS", cast=CommaSeparatedStrings, default="" ) LOGGING_LEVEL = logging.DEBUG if DEBUG else logging.INFO logging.basicConfig( handlers=[InterceptHandler(level=LOGGING_LEVEL)], level=LOGGING_LEVEL
from typing import Dict import uvloop from starlette.config import Config from starlette.datastructures import Secret from schemas.database_url import DatabaseURL from util.toml import project, version # noqa # --- uvloop ----------------------------------------------------------------- # uvloop.install() # configure asyncio to use uvloop as the default event loop # --- general ---------------------------------------------------------------- # conf: Config = Config(env_file=".env") # initialize from .env file, if present ENV: str = conf("ENV", cast=str, default="development") DEBUG: bool = conf("DEBUG", cast=bool, default=False) # --- backends --------------------------------------------------------------- # DATABASE_DRIVER: str = conf("DATABASE_DRIVER", cast=str, default="postgresql+asyncpg") DATABASE_USERNAME: str = conf("DATABASE_USERNAME", cast=str) DATABASE_PASSWORD: Secret = conf("DATABASE_PASSWORD", cast=Secret) DATABASE_HOST: str = conf("DATABASE_HOST", cast=str, default="localhost") DATABASE_PORT: int = conf("DATABASE_PORT", cast=int, default=5432) DATABASE_NAME: str = conf("DATABASE_NAME", cast=str, default=project) DATABASE_POOL_SIZE_MIN: int = conf("DATABASE_POOL_SIZE_MIN",
def config_info(key: str, default_value=None): env = os.getenv("env", "dev") config = Config(".env_{}".format(env)) value = config(key, default=default_value) return value
# def _remove_revision(arn: str) -> str: # """Remove revision number from batch job description arn.""" # arn_items = arn.split(":") # revision = arn_items.pop() # try: # # Check if revision is a number # int(revision) # return ":".join(arn_items) # except (ValueError, TypeError): # # if not, this means that there was no revision number in first place and we can use the input # return arn # Read .env file, if exists p: Path = Path(__file__).parents[2] / ".env" config: Config = Config(p if p.exists() else None) empty_db_secret = { "dbInstanceIdentifier": None, "dbname": None, "engine": None, "host": "localhost", "password": None, # pragma: allowlist secret "port": 5432, "username": None, } empty_sa_secret = {"email": None, "token": None} # As of writing, Fargate doesn't support to fetch secrets by key. # Only entire secret object can be obtained.
username = request.session.get("user") if username == None: return credentials = ["authenticated"] is_admin = False if request.session.get("is_admin", "False") == "Jawohl": credentials.append("admin") is_admin = True return AuthCredentials(credentials), ExtendedUser(username, is_admin) webgui_config = Config("configuration/webgui.env") # Note: PutSomethingRandomHere is the default value in the shipped configuration file. # The app will not start with this value, forcing the users to set their onw secret # key. Therefore, the value is used as default here as well. SECRET_KEY = webgui_config("SECRET_KEY", cast=Secret, default="PutSomethingRandomHere") WEBGUI_PORT = webgui_config("PORT", cast=int, default=8000) WEBGUI_HOST = webgui_config("HOST", default="0.0.0.0") DEBUG_MODE = webgui_config("DEBUG", cast=bool, default=True) app = Starlette(debug=DEBUG_MODE) # Don't check the existence of the static folder because the wrong parent folder is used if the # source code is parsed by sphinx. This would raise an exception and lead to failure of sphinx. app.mount("/static", StaticFiles(directory="webinterface/statics", check_dir=False),
import os from pathlib import Path from starlette.config import Config ROOT_DIR = Path(__file__).parents[1] READ_DOT_ENV_FILE = bool(os.environ.get('READ_DOT_ENV_FILE', default=False)) if READ_DOT_ENV_FILE: config = Config(str(ROOT_DIR / '.env')) else: config = Config() GRAPHQL_SCHEMA_FILE = config('GRAPHQL_SCHEMA_FILE', cast=str, default=str(ROOT_DIR / 'schema.graphql')) GRAPHQL_PATH = config('GRAPHQL_PATH', default='/graphql/') DEBUG = config('DEBUG', cast=bool, default=False) TESTING = config('TESTING', cast=bool, default=False) DATABASE_URL = config( 'DATABASE_URL', default='postgresql://*****:*****@postgres:5432/interagent') REDIS_URL = config('REDIS_URL', default='redis://redis:6379') WITH_JUMP = config('WITH_JUMP', cast=bool, default=False) STATIC = config('STATIC', cast=bool, default=False) if DEBUG:
< transfer-encoding: chunked < * Connection #0 to host localhost left intact """ import os from starlette.applications import Starlette from starlette.config import Config from starlette.datastructures import Secret from starlette.responses import Response, RedirectResponse from starlette.routing import Route from starlette_authlib.middleware import AuthlibMiddleware, SecretKey config = Config(".env") # pylint: disable=invalid-name KEYS_DIR = os.path.join(os.path.dirname(__file__), "keys") # Override this via command line env vars eg. # JWT_ALG=RS256 uvicorn sample_app.app:app JWT_ALG = config("JWT_ALG", cast=str, default="HS256") async def check(request): """ Check if we are in session. """ if not request.session.get("user"): return Response(status_code=401) return Response()
def __init__(self) -> None: self._config = Config(".env")
from starlette.config import Config config = Config("../.env") DB_USER = config("MONGO_INITDB_ROOT_USERNAME") DB_PASSWORD = config("MONGO_INITDB_ROOT_PASSWORD") DB_HOST = config("MONGO_HOST") DB_PORT = config("MONGO_PORT") CORS_ALLOWED = [ x.replace(":80", "") if x.endswith(":80") else x for x in config("CORS_ALLOWED").split(",") ]
import os import click import typing import uvicorn import requests import ujson as json from starlette.config import Config config = Config('/docker/.env', os.environ) @click.group() def cli() -> None: pass @cli.command() @click.option('--debug', is_flag=True) def serve(debug: bool) -> None: uvicorn_kwargs = { 'loop': 'uvloop', 'host': '0.0.0.0', 'port': config('PYTHON_CACHE_APP_PORT', cast=int, default=8000), 'log_level': 'debug' if debug else 'warning', 'proxy_headers': True, } if debug: uvicorn_kwargs.update({ 'reload': True, }) uvicorn.run('cache_app.asgi:app', **uvicorn_kwargs)
from starlette.middleware.sessions import SessionMiddleware from starlette.requests import Request from starlette.responses import JSONResponse, RedirectResponse from ...core.config import oauth_settings, settings from ...core.database import get_database_session from ...core.handlers import set_exception_handlers from ..users.models.domain import UserInfo from ..users.services import sign_up_if_not_signed from ..users.services.kakao import get_user_profile from .models.domain.google import GoogleAuthInfo from .models.domain.landlords import OAuthType from .models.responses import KakaoAuthResponse from .services import create_access_token config = Config("google.env") oauth = OAuth(config) oauth.register( name="google", server_metadata_url=( "https://accounts.google.com/.well-known/openid-configuration" ), client_kwargs={"scope": "openid email profile"}, ) oauth_client = FastAPI() oauth_client.add_middleware(SessionMiddleware, secret_key=settings.SECRET_KEY) set_exception_handlers(oauth_client)
from common.constants import mercure_defs ################################################################################### ## Configuration and initialization ################################################################################### daiquiri.setup( level=logging.INFO, outputs=(daiquiri.output.Stream( formatter=daiquiri.formatter.ColorFormatter( fmt="%(color)s%(levelname)-8.8s " "%(name)s: %(message)s%(color_stop)s")), ), ) logger = daiquiri.getLogger("bookkeeper") bookkeeper_config = Config("configuration/bookkeeper.env") BOOKKEEPER_PORT = bookkeeper_config("PORT", cast=int, default=8080) BOOKKEEPER_HOST = bookkeeper_config("HOST", default="0.0.0.0") DATABASE_URL = bookkeeper_config("DATABASE_URL", default="postgresql://mercure@localhost") database = databases.Database(DATABASE_URL) app = Starlette(debug=True) ################################################################################### ## Definition of database tables ################################################################################### metadata = sqlalchemy.MetaData() engine = sqlalchemy.create_engine(DATABASE_URL) connection = None
from databases import DatabaseURL from starlette.config import Config from starlette.datastructures import Secret config = Config(".env") PROJECT_NAME = "analyticsfans" VERSION = "0.1.0" API_PREFIX = "/api" SECRET_KEY = config("SECRET_KEY", cast=Secret, default="CHANGEME") POSTGRES_USER = config("POSTGRES_USER", cast=str) POSTGRES_PASSWORD = config("POSTGRES_PASSWORD", cast=Secret) POSTGRES_SERVER = config("POSTGRES_SERVER", cast=str, default="db") POSTGRES_PORT = config("POSTGRES_PORT", cast=str, default="5432") POSTGRES_DB = config("POSTGRES_DB", cast=str) DATABASE_URL = config( "DATABASE_URL", cast=DatabaseURL, default=(f"postgresql://{POSTGRES_USER}:{POSTGRES_PASSWORD}" f"@{POSTGRES_SERVER}:{POSTGRES_PORT}/{POSTGRES_DB}"), )
from starlette.config import Config from sqlalchemy.engine.url import URL, make_url from starlette.datastructures import Secret, URLPath config = Config('settings.ini') DEBUG = config('DEBUG', cast=bool, default=True) SEND_EMAILS = config('SEND_EMAILS', cast=bool, default=True) EMAIL_VERIFICATION_IS_NEEDED = config('EMAIL_VERIFICATION_IS_NEEDED', cast=bool, default=False) ALLOW_EVERYONE_CREATE_ITEMS = config('ALLOW_EVERYONE_CREATE_ITEMS', cast=bool, default=True) SECRET_KEY = config('SECRET_KEY', default='') ALGORITHM = "HS256" ACCESS_TOKEN_EXPIRE_DAYS = 7 DB_DRIVER = config("DB_DRIVER", default="postgresql") DB_NAME = config('DB_NAME', default='demando') TEST_DB_NAME = config('TEST_DB_NAME', default='demando') DB_USER = config('DB_USER', default='demando') DB_USER_PASSWORD = config('DB_USER_PASSWORD', cast=Secret, default='1234') DB_HOST = config('DB_HOST', cast=str, default='db') DB_PORT = config('DB_PORT', cast=int, default='5432') DB_DSN = config('DB_DSN',