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',
