def __init__(self):
self._config = None
self.env = Env()
self.env.read_env()
print( # noqa: T001
'Using overridden values for',
self.ENV_VARS.intersection(os.environ.keys()),
file=sys.stderr,
)
import os
from environs import Env, EnvError
from marshmallow.validate import OneOf, Email, Length
os.environ["TTL"] = "-2"
os.environ["NODE_ENV"] = "invalid"
os.environ["EMAIL"] = "^_^"
env = Env()
# simple validator
try:
env.int("TTL", validate=lambda n: n > 0) # => 'sloria'
except EnvError as err:
print(err)
# marshmallow validator
try:
env.str(
"NODE_ENV",
validate=OneOf(["production", "development"],
error="NODE_ENV must be one of: {choices}"),
)
except EnvError as err:
print(err)
# multiple validators
try:
env.str("EMAIL", validate=[Length(min=4), Email()])
except EnvError as err:
import os
from pathlib import Path
from environs import Env
env = Env()
env.read_env('.env')
BASE_DIR = Path(__file__).resolve().parent.parent
SECRET_KEY = env.str('SECRET_KEY')
DEBUG = env.bool('DEBUG')
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'store.apps.StoreConfig',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
Generated by 'django-admin startproject' using Django 3.1.7.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
from pathlib import Path
from environs import Env
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
ENV = Env()
ENV.read_env()
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = ENV.str('SECRET_KEY')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
import os
from environs import Env
# Prefixed envvars
os.environ["CANTEEN_HOST"] = "lolcathost"
os.environ["CANTEEN_PORT"] = "3000"
# A non-prefixed envvar
os.environ["NODE_ENV"] = "production"
env = Env()
with env.prefixed("CANTEEN_"):
host = env.str("HOST", "localhost")
port = env.int("PORT", 5000)
node_env = env.str("NODE_ENV", "development")
assert host == "lolcathost"
assert port == 3000
assert node_env == "production"
print(env.dump())
from environs import Env
os.environ["GITHUB_USER"] = "******"
os.environ["API_KEY"] = "123abc"
os.environ["SHIP_DATE"] = "1984-06-25"
os.environ["ENABLE_LOGIN"] = "******"
os.environ["MAX_CONNECTIONS"] = "42"
os.environ["GITHUB_REPOS"] = "webargs,konch,ped"
os.environ["COORDINATES"] = "23.3,50.0"
os.environ["MYAPP_HOST"] = "lolcathost"
os.environ["MYAPP_PORT"] = "3000"
env = Env()
# reading an environment variable
gh_user = env("GITHUB_USER") # => 'sloria'
# casting
api_key = env.str("API_KEY") # => '123abc'
date = env.date("SHIP_DATE") # => datetime.date(1984, 6, 25)
# providing a default value
enable_login = env.bool("ENABLE_LOGIN", False) # => True
enable_feature_x = env.bool("ENABLE_FEATURE_X", False) # => False
# parsing lists
gh_repos = env.list("GITHUB_REPOS") # => ['webargs', 'konch', 'ped']
coords = env.list("COORDINATES", subcast=float) # => [23.3, 50.0]
with env.prefixed("MYAPP_"):
host = env("HOST", "localhost")
port = env.int("PORT", 5000)
class Config:
ENV_VARS = {
'API_ALLOW_DEBUG',
'API_HOST',
'API_WS_PORT',
'CACHE_HOST',
'CACHE_PORT',
'CACHE_SIGN_KEY',
'CACHE_TIMEOUT',
'CACHE_TTL',
'ENV',
'LOG_LEVEL',
'ROLLBAR_ACCESS_TOKEN',
'ROLLBAR_LEVEL',
'VERSION',
}
def __init__(self):
self._config = None
self.env = Env()
self.env.read_env()
print( # noqa: T001
'Using overridden values for',
self.ENV_VARS.intersection(os.environ.keys()),
file=sys.stderr,
)
def __getitem__(self, value):
if self._config is None:
raise RuntimeError('Config is not loaded, cannot access it')
return self._config[value]
def setup_config(self):
# API must not start in prod like nev if we don't have a sign key for cache.
# This is for security reasons.
env = self.env.str('ENV', 'production')
cache_sign_key = self.env.str('CACHE_SIGN_KEY', '')
if env != 'development' and not cache_sign_key:
raise EnvironmentError('You must supply a CACHE_SIGN_KEY env var')
self._config = MappingProxyType({
'api': {
'allow_debug': self.env.bool('API_ALLOW_DEBUG', False),
# Binding to all interfaces, bandit don't allow this (#104)
'host': self.env.str('API_HOST', '0.0.0.0'), # noqa: S104
'ws_port': self.env.int('API_WS_PORT', 8181),
},
'cache': {
'host': self.env.str('CACHE_HOST', 'aot-redis'),
'port': self.env.int('CACHE_PORT', 6379),
# Sign key must be of type bytes, not str.
'sign_key': cache_sign_key.encode('utf-8'),
'timeout': self.env.int('CACHE_TIMEOUT', 5),
'ttl': self.env.int('CACHE_TTL', 2 * 24 * 60 * 60), # 2 days
},
# Amount of time to wait for pending futures before forcing them to shutdown.
'cleanup_timeout': self.env.int('CLEANUP_TIMEOUT', 5),
'env': env,
'log': {
'level': self.env.str('LOG_LEVEL', None),
},
'rollbar': {
'access_token': self.env.str('ROLLBAR_ACCESS_TOKEN', None),
'level': self.env.int('ROLLBAR_LEVEL', 30),
},
'version': self.env.str('VERSION', 'latest'),
})
Django settings for forenings_medlemmer project.
For more information on this file, see
https://docs.djangoproject.com/en/1.7/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.7/ref/settings/
"""
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os
import logging
from environs import Env
import dj_database_url
env = Env()
env.read_env()
logger = logging.getLogger(__name__)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [
# insert your TEMPLATE_DIRS here
],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
import sys
import os
from environs import Env
env = Env()
FROM_EXAMPLE = env.bool('FROM_EXAMPLE', False)
if FROM_EXAMPLE:
from dotenv import load_dotenv
load_dotenv('./mishards/.env.example')
else:
env.read_env()
SERVER_VERSIONS = ['1.0.x']
DEBUG = env.bool('DEBUG', False)
MAX_RETRY = env.int('MAX_RETRY', 3)
LOG_LEVEL = env.str('LOG_LEVEL', 'DEBUG' if DEBUG else 'INFO')
LOG_PATH = env.str('LOG_PATH', '/tmp/mishards')
LOG_NAME = env.str('LOG_NAME', 'logfile')
TIMEZONE = env.str('TIMEZONE', 'UTC')
from utils.logger_helper import config
config(LOG_LEVEL, LOG_PATH, LOG_NAME, TIMEZONE)
SERVER_PORT = env.int('SERVER_PORT', 19530)
SERVER_TEST_PORT = env.int('SERVER_TEST_PORT', 19530)
WOSERVER = env.str('WOSERVER')
MAX_WORKERS = env.int('MAX_WORKERS', 50)
import logging
from environs import Env
env = Env()
training_service_config = {
"host": env("TRAINING_SERVICE_HOST"),
"port": env("TRAINING_SERVICE_PORT"),
"api_train_path": env("TRAINING_SERVICE_API_TRAIN_PATH"),
"timeout": env.int("TRAINING_REQUESTS_TIMEOUT"),
"appinsights_key": env("APP_INSIGHTS_INSTRUMENTATION_KEY")
}
mlflow_models_mapping = env.json('MLFLOW_MODELS_MAPPING')
service_config = {
"service_name": env("SERVICE_NAME"),
"log_level": env.int("LOG_LEVEL", logging.INFO),
"port": env.int("PORT", 80)
}
def __init__(self, home_path=None, config_path=None):
if not home_path or not Path(home_path).resolve().exists():
raise ValueError("environment variable DIRECTOR_HOME is not set correctly")
self.DIRECTOR_HOME = env_path = str(home_path)
if config_path:
if not Path(config_path).resolve().exists():
raise ValueError(
"environment variable DIRECTOR_CONFIG is not set correctly"
)
env_path = config_path
env = Env()
env.read_env(env_path)
self.ENABLE_DARK_THEME = env.bool("DIRECTOR_ENABLE_DARK_THEME", False)
self.ENABLE_HISTORY_MODE = env.bool("DIRECTOR_ENABLE_HISTORY_MODE", False)
self.ENABLE_CDN = env.bool("DIRECTOR_ENABLE_CDN", True)
self.STATIC_FOLDER = env.str(
"DIRECTOR_STATIC_FOLDER", str(Path(self.DIRECTOR_HOME).resolve() / "static")
)
self.API_URL = env.str("DIRECTOR_API_URL", "http://127.0.0.1:8000/api")
self.FLOWER_URL = env.str("DIRECTOR_FLOWER_URL", "http://127.0.0.1:5555")
self.WORKFLOWS_PER_PAGE = env.int("DIRECTOR_WORKFLOWS_PER_PAGE", 1000)
self.REFRESH_INTERVAL = env.int("DIRECTOR_REFRESH_INTERVAL", 30000)
# Authentication
self.AUTH_ENABLED = env.bool("DIRECTOR_AUTH_ENABLED", False)
# SQLAlchemy configuration
self.SQLALCHEMY_TRACK_MODIFICATIONS = False
self.SQLALCHEMY_DATABASE_URI = env.str("DIRECTOR_DATABASE_URI", "")
self.SQLALCHEMY_ENGINE_OPTIONS = {
"pool_recycle": env.int("DIRECTOR_DATABASE_POOL_RECYCLE", -1),
}
# Celery configuration
self.CELERY_CONF = {
"task_always_eager": False,
"broker_url": env.str("DIRECTOR_BROKER_URI", "redis://localhost:6379/0"),
"result_backend": env.str(
"DIRECTOR_RESULT_BACKEND_URI", "redis://localhost:6379/1"
),
"broker_transport_options": {"master_name": "director"},
}
# Sentry configuration
self.SENTRY_DSN = env.str("DIRECTOR_SENTRY_DSN", "")
import datetime
import os
import subprocess
import time
from difflib import unified_diff
import requests
from environs import Env
env = Env()
env.read_env()
URL_BASE = env.str("URL_BASE")
class Client:
last = None
ping_interval: int = 60 * 60 # 1 hour
def __init__(self, interval_in_seconds: int, api_key: str):
assert interval_in_seconds > 10
self.interval: int = interval_in_seconds
self.api_key = api_key
def loop(self):
raise NotImplementedError
def ping(self):
requests.post(f"{URL_BASE}/ping", json={"key": self.api_key})
def on_update(self, new):
import os
import sys
from environs import Env
env = Env()
env.read_env()
DATABASES = {
"default": {
"ENGINE": "django.db.backends.postgresql_psycopg2",
"HOST": env("DATABASE_HOST"),
"PORT": env("DATABASE_PORT"),
"NAME": env("DATABASE_NAME"),
"USER": env("DATABASE_USER"),
"PASSWORD": env("DATABASE_PASSWORD"),
}
}
INSTALLED_APPS = ["datacenter"]
SECRET_KEY = env("DJANGO_SECRET_KEY")
DEBUG = env.bool("DJANGO_DEBUG", default=True)
ROOT_URLCONF = "project.urls"
ALLOWED_HOSTS = env.list("DJANGO_ALLOWED_HOSTS")
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TEMPLATES = [
"""
Django settings for config project.
Generated by 'django-admin startproject' using Django 3.1.5.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
from pathlib import Path
from environs import Env
env = Env()
env.read_env()
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env.str("SECRET_KEY")
#env.str('SECRET_KEY')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = env.bool("DEBUG", default=False)
#env.bool("DEBUG", default=False)
"""
Django settings for MediDoc project.
Generated by 'django-admin startproject' using Django 3.0.7.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.0/ref/settings/
"""
import os
from environs import Env
env = Env()
env.read_env()
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env.str("SECRET_KEY")
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = env.bool("DEBUG", default=True)
ALLOWED_HOSTS = []
# -*- coding: utf-8 -*-
"""Application configuration.
Most configuration is set via environment variables.
For local development, use a .env file to set
environment variables.
"""
from environs import Env
env = Env()
env.read_env()
ENV = env.str('FLASK_ENV', default='production')
DEBUG = ENV == 'development'
SQLALCHEMY_DATABASE_URI = env.str('DATABASE_URL')
SECRET_KEY = env.str('SECRET_KEY')
BCRYPT_LOG_ROUNDS = env.int('BCRYPT_LOG_ROUNDS', default=13)
DEBUG_TB_ENABLED = DEBUG
DEBUG_TB_INTERCEPT_REDIRECTS = False
CACHE_TYPE = 'simple' # Can be "memcached", "redis", etc.
SQLALCHEMY_TRACK_MODIFICATIONS = False
WEBPACK_MANIFEST_PATH = 'webpack/manifest.json'
import sys
from environs import Env, EnvError
CONNECTION_STRING_FORMAT = 'postgresql+psycopg2://%s:%s@%s:%s/%s'
env = Env()
env.read_env()
def get_db_url():
user = env.str('DB_USER')
password = env.str('DB_PASSWORD')
host = env.str('DB_HOST')
port = env.str('DB_PORT')
name = env.str('DB_NAME')
return CONNECTION_STRING_FORMAT % (
user,
password,
host,
port,
name
)
def get_env_config():
env_config = {}
try:
env_config.update({
'sqlalchemy_database_uri': get_db_url(),
import time
import grpc
import locust
from environs import Env
from ai_serving_pb2 import RecordSpec, Record, PredictRequest, Value, ListValue
from ai_serving_pb2_grpc import DeploymentServiceStub
env = Env()
MODEL_NAME = env.str('MODEL_NAME', 'lgb')
HOST = env.str('HOST', 'localhost:9091')
DATA_SIZE = env.int('DATA_SIZE', 100)
class Test(locust.User):
def on_start(self):
channel = grpc.insecure_channel(HOST)
self.stub = DeploymentServiceStub(channel)
data = [0.5 for _ in range(13)] + [1 for _ in range(26)]
values = ListValue(values=[Value(number_value=x) for x in data])
values = Value(list_value=values)
values = ListValue(values=[values for _ in range(DATA_SIZE)])
self.request = PredictRequest(X=RecordSpec(
records=[Record(fields={
'num_feat': Value(list_value=values)
})]))
self.request.model_spec.name = MODEL_NAME
@locust.task
import os
from environ import Env as DjangoEnv
from environs import Env
env = Env()
env.add_parser('db_settings', DjangoEnv.db_url_config)
env.add_parser('email_settings', DjangoEnv.email_url_config)
PROJECT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
VAR_DIR = os.path.join(PROJECT_DIR, 'var')
INSTALLED_APPS = [
# Rules for this list:
# - Group apps by module
# - Sort groups by time (recently added go last)
# - Sort apps within a group alphabetically
# - If you need to place an app out of order, leave a comment explaining the reason why.
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.staticfiles',
'aldjemy',
'funrun.match',
'funrun.history',
]
MIDDLEWARE_CLASSES = [
import json
from datetime import datetime, timezone
import requests
from environs import Env
from furl import furl
env = Env()
GITHUB_TOKEN = env.str("GITHUB_TOKEN")
session = requests.Session()
session.headers = {
"User-Agent": "OpenSAFELY Jobs",
}
class GitHubAPI:
"""
A thin wrapper around requests, furl, and the GitHub API.
Initialising this class with a token will set that token in the sessions
headers.
"public" functions should construct a URL and make requests against the
session object attached to the instance.
This object is not expected to be used in most tests so we can avoid mocking.
from environs import Env
env = Env()
env.read_env()
SECRET_KEY = env('SECRET_KEY', '')
DEBUG = env.bool('DEBUG', False)
HTTP_HOST = env('HTTP_HOST', 'localhost')
HTTP_PORT = env.int('HTTP_PORT', 8085)
DB_HOST = env('DB_HOST', 'localhost')
DB_PORT = env.int('DB_PORT', 5432)
DB_NAME = env('DB_NAME', 'airy')
DB_USERNAME = env('DB_USERNAME', 'airy')
DB_PASSWORD = env('DB_PASSWORD', 'airy')
TIMEZONE = env('TIMEZONE', 'Europe/Moscow')
SMTP_SERVER = env('SMTP_SERVER', 'localhost')
SMTP_PORT = env.int('SMTP_PORT', 25)
SMTP_USER = env('SMTP_USER', '')
SMTP_PASSWORD = env('SMTP_PASSWORD', '')
SMTP_SENDER = env('SMTP_SENDER', 'no-reply@localhost')
USER_NAME = env('USER_NAME', 'username')
USER_PASSWORD = env('USER_PASSWORD', 'password')
USER_EMAIL = env('USER_EMAIL')
#
# This software contains code licensed as described in LICENSE.
#
# See MOTL_Simp_15.py for a commented script
import time
import logging
from environs import Env
import lgsvl
FORMAT = "[%(levelname)6s] [%(name)s] %(message)s"
logging.basicConfig(level=logging.WARNING, format=FORMAT)
log = logging.getLogger(__name__)
env = Env()
MAX_SPEED = 11.111 # (40 km/h, 25 mph)
SPEED_VARIANCE = 4
TIME_LIMIT = 30 # seconds
PARKING_ZONE_LENGTH = 24 # meters
LGSVL__SIMULATOR_HOST = env.str("LGSVL__SIMULATOR_HOST", "127.0.0.1")
LGSVL__SIMULATOR_PORT = env.int("LGSVL__SIMULATOR_PORT", 8181)
LGSVL__AUTOPILOT_0_HOST = env.str("LGSVL__AUTOPILOT_0_HOST", "127.0.0.1")
LGSVL__AUTOPILOT_0_PORT = env.int("LGSVL__AUTOPILOT_0_PORT", 9090)
print("MOTL_Simp_25 - ", end='')
sim = lgsvl.Simulator(LGSVL__SIMULATOR_HOST, LGSVL__SIMULATOR_PORT)
scene_name = env.str(
import os
from environs import Env
print("start local")
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
print('BASE_DIR : {}'.format(BASE_DIR))
env = Env()
THE_ENV=os.path.join(BASE_DIR,'..','env','.env')
env.read_env(path=THE_ENV)
print('The .env file has been loaded. env: '+str(THE_ENV))
from .base import *
ENV_TYPE = LOC
ALLOWED_HOSTS = ['*','127.0.0.1',SERVER]
DEBUG_TOOLBAR_CONFIG = {
'DISABLE_PANELS': [ 'debug_toolbar.panels.redirects.RedirectsPanel', ],
'SHOW_TEMPLATE_CONTEXT': True,
}
INTERNAL_IPS = ['127.0.0.1', '192.168.0.1']
#get local urls for services
file_dir = os.path.dirname(__file__)
file_path = os.path.join(file_dir,'..','..','env', 'loc_settings.json')
with open(file_path, 'r') as fi:
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.0/ref/settings/
"""
# pylint: skip-file
import os
import socket
from django.contrib.messages import constants as message_constants
from environs import Env
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
env = Env()
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env('SECRET_KEY',
'++apz(*cojac+1u$io&w)wg^r5vgaon%@wvpd#@j5iv9!9#lsg')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = env.bool('DEBUG', True)
ALLOWED_HOSTS = env('DJANGO_ALLOWED_HOSTS', 'localhost').split(" ")
# Application definition
async def delete_role(request, role_id):
"""Delete a role by it's next_id.
Args:
role_id:
str: the role_id field of the targeted role
Returns:
json:
dict: {
message:
str: the status of the role delete operation
deleted:
int: count of the number of roles that were deleted
}
Raises:
ApiForbidden:
The user is not a system admin or owner of the targeted
role.
ApiNotFound:
The role does not exist in RethinkDB.
ApiInternalError:
There was an error compiling blockchain transactions.
"""
log_request(request)
env = Env()
if not env.int("ENABLE_NEXT_BASE_USE"):
raise ApiDisabled("Not a valid action. Source not enabled")
txn_key, txn_user_id = await get_transactor_key(request)
# does the role exist?
conn = await create_connection()
if not await roles_query.does_role_exist(conn, role_id):
LOGGER.warning(
"Nonexistent Role – User %s is attempting to delete the nonexistent role %s",
txn_user_id,
role_id,
)
return await handle_not_found(
request, ApiNotFound("The targeted role does not exist.")
)
conn.close()
is_role_owner = await check_role_owner_status(txn_user_id, role_id)
if not is_role_owner:
is_admin = await check_admin_status(txn_user_id)
if not is_admin:
LOGGER.warning(
"Permission Denied – User %s does not have sufficient privilege to delete role %s.",
txn_user_id,
role_id,
)
return await handle_errors(
request, ApiForbidden("You do not have permission to delete this role.")
)
txn_list = []
txn_list = await create_rjct_ppsls_role_txns(
txn_key, role_id, txn_user_id, txn_list
)
txn_list = await create_del_admin_by_role_txns(txn_key, role_id, txn_list)
txn_list = await create_del_mmbr_by_role_txns(txn_key, role_id, txn_list)
txn_list = await create_del_ownr_by_role_txns(txn_key, role_id, txn_list)
txn_list = create_del_role_txns(txn_key, role_id, txn_list)
# validate transaction list
if not txn_list:
LOGGER.warning(
"txn_list is empty. There was an error processing the delete role transactions. Transaction list: %s",
txn_list,
)
return await handle_errors(
request,
ApiInternalError(
"An error occurred while creating the blockchain transactions to delete the role."
),
)
batch = batcher.make_batch_from_txns(transactions=txn_list, signer_keypair=txn_key)
batch_list = batcher.batch_to_list(batch=batch)
await send(request.app.config.VAL_CONN, batch_list, request.app.config.TIMEOUT)
return json(
{"message": "Role {} successfully deleted".format(role_id), "deleted": 1}
)
from environs import Env
env = Env()
env.read_env()
DATABASE_URI = env.str("DATABASE_URI")
DEBUG = env.str("DEBUG", False)
FCM_API_KEY = env.str("FCM_API_KEY")
INARA_API_KEY = env.str("INARA_API_KEY")
import pika
from environs import Env
env = Env()
env.read_env('.env') # read .env file, if it exists
# required variables
HOST: str = env("HOST_RABBIT")
USER: str = env("USER_RABBIT")
PASSWORD: str = env("PASSWORD_RABBIT")
PORT: int = env.int("PORT_RABBIT")
# providing a default value
enable_login: bool = env.bool("ENABLE_LOGIN", False) # => True
def get_rabbit_connection():
credentials = pika.PlainCredentials(USER, PASSWORD) # login + pass
connection = pika.BlockingConnection(
pika.ConnectionParameters(
host=HOST, # host, in Google Cloud Internal IP
port=PORT, # port, usually 5672 or 15672
credentials=credentials # login + pass))
))
channel = connection.channel()
return channel
import pprint
import environs
from environs import Env
from food_management.erreurs.exceptions import ErreurFichierEnvironnement
try:
os_env_var = os.environ
print("User's Environment variable:")
pprint.pprint(dict(os_env_var), width=1)
"""
Démo : on accède aux variables d'environnement existantes
"""
obj_env = Env()
computer_name = obj_env("COMPUTERNAME")
print("computer_name ", computer_name)
"""
Démo : on accède aux variables d'environnement de l'utilisateur
"""
try:
"""
obj_env("PORT_MYSQL") permet de récupérer le num. du port dans le fichier ".env"
obj_env.int("PORT_FLASK") permet de récupérer le num. du port (INTEGER) dans le fichier ".env"
"""
obj_env.read_env()
DEMO_PORT_MYSQL = obj_env("PORT_MYSQL")
print("DEMO_PORT_MYSQL dans le fichier \".env\" ", DEMO_PORT_MYSQL)
DEMO_PORT_FLASK = obj_env.int("PORT_FLASK")
"""
Django settings for hotzone_config project.
Generated by 'django-admin startproject' using Django 3.1.2.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
from pathlib import Path
from environs import Env
env = Env()
env.read_env()
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env('HOTZONE_SECRET_KEY')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False
ALLOWED_HOSTS = ['hotzone-p-3.herokuapp.com', 'localhost', '127.0.0.1']
"""
Django settings for api project.
Generated by 'django-admin startproject' using Django 3.1.4.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
import os
from pathlib import Path
from environs import Env
env = Env()
env.read_env()
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env("SECRET_KEY")
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = env.bool("DEBUG")
ALLOWED_HOSTS = ['cart-rest-api.herokuapp.com', '127.0.0.1']
import os
import pathlib
import marshmallow as ma
from environs import Env
os.environ['STATIC_PATH'] = 'app/static'
class PathField(ma.fields.Field):
def _deserialize(self, value, *args, **kwargs):
return pathlib.Path(value)
def _serialize(self, value, *args, **kwargs):
return str(value)
env = Env()
env.parser_from_field('path', PathField)
static_path = env.path('STATIC_PATH')
assert isinstance(static_path, pathlib.Path)
print(env.dump())
def default(cls):
"""Ignore environmental variables and use all default arguments as defined above"""
# Put empty env to force using the given defaults
cls.env = Env()
cls.__init__(cls)
import os
from environs import Env, EnvError
from marshmallow.validate import OneOf, Email, Length
os.environ["TTL"] = "-2"
os.environ["NODE_ENV"] = "invalid"
os.environ["EMAIL"] = "^_^"
env = Env()
# simple validator
try:
env.int("TTL", validate=lambda n: n > 0) # => 'sloria'
except EnvError as err:
print(err)
# marshmallow validator
try:
env.str(
"NODE_ENV",
validate=OneOf(
["production", "development"], error="NODE_ENV must be one of: {choices}"
),
)
except EnvError as err:
print(err)
from environs import Env
env = Env()
DEBUG = env.bool('DEBUG', default=False)
BIND_HOST = env('BIND_HOST', default='0.0.0.0')
BIND_PORT = env.int('BIND_PORT', default=8888)
NEO4J_HOST = env('NEO4J_HOST', default='127.0.0.1')
NEO4J_PORT = env.int('NEO4J_PORT', default=7687)
NEO4J_USER = env('NEO4J_USER', default='neo4j')
NEO4J_PASSWORD = env('NEO4J_PASSWORD', default='neo4j')
NEO4J_SCHEME = env('NEO4J_SCHEME', default='bolt+routing')
SECRET_KEY = env("SECRET_KEY", "I'm Ron Burgundy?")
START_PAGIN = env.int('START_PAGIN', default=0)
LIMIT_PAGIN = env.int('LIMIT_PAGIN', default=1000)
LIMIT_NEWS = env.int('LIMIT_NEWS', default=1000)
"""Application configuration.
Most configuration is set via environment variables.
For local development, use a .env file to set
environment variables.
"""
from os.path import abspath, dirname, join
from environs import Env
basedir = dirname(abspath(__file__))
env = Env()
env.read_env()
ENV = env.str('FLASK_ENV', default='production')
DEBUG = ENV == 'development'
SQLALCHEMY_DATABASE_URI = env.str('DATABASE_URL', default='sqlite:////' +
join(basedir, 'db.sqlite3'))
SECRET_KEY = env.str('SECRET_KEY')
BCRYPT_LOG_ROUNDS = env.int('BCRYPT_LOG_ROUNDS', default=13)
DEBUG_TB_ENABLED = DEBUG
DEBUG_TB_INTERCEPT_REDIRECTS = False
CACHE_TYPE = 'simple' # Can be "memcached", "redis", etc.
SQLALCHEMY_TRACK_MODIFICATIONS = False
WEBPACK_MANIFEST_PATH = 'webpack/manifest.json'
SECURITY_PASSWORD_SALT = SECRET_KEY
SECURITY_TRACKABLE = True
import platform
from os.path import dirname, abspath, join
from environs import Env
from loguru import logger
from proxypool.utils.parse import parse_redis_connection_string
env = Env()
env.read_env()
# definition of flags
IS_WINDOWS = platform.system().lower() == 'windows'
# definition of dirs
ROOT_DIR = dirname(dirname(abspath(__file__)))
LOG_DIR = join(ROOT_DIR, env.str('LOG_DIR', 'logs'))
# definition of environments
DEV_MODE, TEST_MODE, PROD_MODE = 'dev', 'test', 'prod'
APP_ENV = env.str('APP_ENV', DEV_MODE).lower()
APP_DEBUG = env.bool('APP_DEBUG', True if APP_ENV == DEV_MODE else False)
APP_DEV = IS_DEV = APP_ENV == DEV_MODE
APP_PROD = IS_PROD = APP_ENV == PROD_MODE
APP_TEST = IS_TEST = APP_ENV == TEST_MODE
# redis host
REDIS_HOST = env.str('REDIS_HOST', '127.0.0.1')
# redis port
REDIS_PORT = env.int('REDIS_PORT', 6379)
# redis password, if no password, set it to None
REDIS_PASSWORD = env.str('REDIS_PASSWORD', None)
import os
import pathlib
import marshmallow as ma
from environs import Env
os.environ["STATIC_PATH"] = "app/static"
class PathField(ma.fields.Field):
def _deserialize(self, value, *args, **kwargs):
return pathlib.Path(value)
def _serialize(self, value, *args, **kwargs):
return str(value)
env = Env()
env.parser_from_field("path", PathField)
static_path = env.path("STATIC_PATH")
assert isinstance(static_path, pathlib.Path)
print(env.dump())
import logging
import os
import sys
from typing import List
from environs import Env
env = Env()
env.read_env()
BASE_MESSAGE_FORMAT = "[%(asctime)s] [%(name)s:%(levelname)s] " \
"[%(module)s:%(funcName)s():%(process)d]"
DATE_FORMAT = "%d-%m-%Y %H:%M:%S"
LOG_FOLDER = env.path('LOG_FOLDER')
DEBUG = env.bool('DEBUG')
try:
os.makedirs(LOG_FOLDER, exist_ok=True)
except PermissionError as e:
pass
class LevelFilter(logging.Filter):
def __init__(self,
levels: List[int] = None) -> None:
self._levels = levels or []
super().__init__(self.__class__.__name__)
def filter(self,
import os
from environs import Env
# Prefixed envvars
os.environ['CANTEEN_HOST'] = 'lolcathost'
os.environ['CANTEEN_PORT'] = '3000'
# A non-prefixed envvar
os.environ['NODE_ENV'] = 'production'
env = Env()
with env.prefixed('CANTEEN_'):
host = env.str('HOST', 'localhost')
port = env.int('PORT', 5000)
node_env = env.str('NODE_ENV', 'development')
assert host == 'lolcathost'
assert port == 3000
assert node_env == 'production'
print(env.dump())
"""
Django settings for config project.
Generated by 'django-admin startproject' using Django 3.1.5.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
from pathlib import Path
from environs import Env
env = Env()
env.read_env()
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env.str('SECRET_KEY')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = env.bool("DEBUG", default=False)
ALLOWED_HOSTS = ['.herokuapp.com', 'localhost', '127.0.0.1']
Generated by 'django-admin startproject' using Django 3.1.1.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
import sys
from pathlib import Path
from celery.schedules import crontab
from environs import Env
env = Env()
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parents[2]
POSTS_API_DIR = BASE_DIR / "posts_api"
sys.path.append(str(POSTS_API_DIR))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env.str("SECRET_KEY")
# SECURITY WARNING: don't run with debug turned on in production!
from datetime import datetime, timedelta
import jwt
from environs import Env
from fastapi import APIRouter, Depends, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
router = APIRouter()
env = Env()
env.read_env()
with env.prefixed("JWT_"):
algorithm = env("ALGORITHM")
subject = env("TOKEN_SUBJECT")
expiry = env.int("ACCESS_TOKEN_EXPIRE_MINUTES")
username = env("USERNAME")
password = env("PASSWORD")
secret = env("RANDOM_SECRET")
tally_user = env("TALLY_USERNAME")
tally_pass = env("TALLY_PASSWORD")
def create_access_token(*, data: dict, expires_delta: timedelta = None):
to_encode = data.copy()
if expires_delta:
expire = datetime.utcnow() + expires_delta
else: # pragma: no cover
expire = datetime.utcnow() + timedelta(minutes=expiry)
to_encode.update({"exp": expire, "sub": subject})
encoded_jwt = jwt.encode(to_encode, secret, algorithm=algorithm)
return encoded_jwt
##### This is the beginning of the plugin code #####
def furl_parser(value):
return Furl(value)
def urlparse_parser(value):
return URL(value)
def setup(env):
env.add_parser("furl", furl_parser)
env.add_parser("yurl", urlparse_parser)
##### End of the plugin code #####
os.environ["GITHUB_URL"] = "https://github.com/sloria/environs"
# Our application activates the plugin using the setup function
env = Env()
setup(env)
# We now have the 'furl' and 'yurl' methods available
github_furl = env.furl("GITHUB_URL")
github_yurl = env.yurl("GITHUB_URL")
import os
from environs import Env
env = Env()
env.read_env()
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'HOST': env('DATABASE_HOST'),
'PORT': env('DATABASE_PORT'),
'NAME': env('DATABASE_NAME'),
'USER': env('DATABASE_USER'),
'PASSWORD': env('DATABASE_PASSWORD'),
}
}
INSTALLED_APPS = ['datacenter']
SECRET_KEY = env('SECRET_KEY')
DEBUG = env.bool('DEBUG')
ROOT_URLCONF = "project.urls"
ALLOWED_HOSTS = ['*']
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
import urlparse
from furl import furl as Furl
from environs import Env
##### This is the beginning of the plugin code #####
def furl_parser(value):
return Furl(value)
def urlparse_parser(value):
return urlparse.urlparse(value)
def setup(env):
env.add_parser('furl', furl_parser)
env.add_parser('purl', urlparse_parser)
##### End of the plugin code #####
os.environ['GITHUB_URL'] = 'https://github.com/sloria/environs'
# Our application activates the plugin using the setup function
env = Env()
setup(env)
# We now have the 'furl' and 'purl' methods available
github_furl = env.furl('GITHUB_URL')
github_purl = env.purl('GITHUB_URL')
# add attribute for loggedIn: NOT_LOGGED_IN
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from flask_cors import CORS
from flask_heroku import Heroku
from environs import Env
import os
app = Flask(__name__)
CORS(app)
heroku = Heroku(app)
env= Env()
env.read_env()
DATABASE_URL = env('DATABASE_URL')
basedir = os.path.abspath(os.path.dirname(__file__))
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///" + os.path.join(basedir, "app.sqlite")
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
# app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URL
db = SQLAlchemy(app)
ma = Marshmallow(app)
## USER CLASS ##
class User(db.Model):
__tablename__ = 'user'
import os
from environs import Env, EnvError
from marshmallow.validate import OneOf, Email, Length
os.environ['TTL'] = '-2'
os.environ['NODE_ENV'] = 'invalid'
os.environ['EMAIL'] = '^_^'
env = Env()
# simple validator
try:
env.int('TTL', validate=lambda n: n > 0) # => 'sloria'
except EnvError as err:
print(err)
# marshmallow validator
try:
env.str('NODE_ENV',
validate=OneOf(['production', 'development'],
error='NODE_ENV must be one of: {choices}'))
except EnvError as err:
print(err)
# multiple validators
try:
env.str('EMAIL',
For more information on this file, see
https://docs.djangoproject.com/en/3.0/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.0/ref/settings/
"""
# 导入配置
from environs import Env
from django3template.setting.log import *
# 默认dev环境
try:
env = Env()
runtime_environment = env("RUNTIME_ENVIRONMENT")
if "PRD" == runtime_environment:
from django3template.setting.prd import *
elif "DEV" == runtime_environment:
from django3template.setting.dev import *
else:
pass
except:
from django3template.setting.dev import *
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '!h%sqh+*bf^&0yffi=t8v#_yv^q4ec5o56*+^@!&=om+1_nwxi'
# Django settings for checkerservice project.
#https://blog.apptension.com/2017/11/09/how-to-configure-django-project-for-multiple-environments/
import os
from environs import Env
import json
print("start base")
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
env = Env()
ENV = env.str('FLASK_ENV', default='production')
DEBUG = ENV == 'development'
SQLALCHEMY_DATABASE_URI = env.str('DATABASE_URL')
SECRET_KEY = env.str('SECRET_KEY')
BCRYPT_LOG_ROUNDS = env.int('BCRYPT_LOG_ROUNDS', default=13)
DEBUG_TB_ENABLED = DEBUG
DEBUG_TB_INTERCEPT_REDIRECTS = False
CACHE_TYPE = 'simple' # Can be "memcached", "redis", etc.
SQLALCHEMY_TRACK_MODIFICATIONS = False
WEBPACK_MANIFEST_PATH = 'webpack/manifest.json'
WTF_CSRF_CHECK_DEFAULT = False
LOC = 'loc'
DEV = 'dev'
TST = 'tst'
PRD = 'prd'
# -*- coding: utf-8 -*-
"""Application settings."""
import logging
import os
from environs import Env
env = Env()
env.read_env()
FLASK_ENV = env("FLASK_ENV")
LOG_LEVEL = (env("LOG_LEVEL", default="") or logging.getLevelName(logging.WARNING)).upper()
LOCAL_TIMEZONE = env("LOCAL_TIMEZONE", default="Europe/Berlin")
TELEGRAM_TOKEN = env("TELEGRAM_TOKEN", default=None)
TELEGRAM_IDLE_TIMEOUT = env.int("TELEGRAM_IDLE_TIMEOUT", default=120)
# By default, database will be refreshed every time a test runs.
REFRESH_TEST_DATABASE = env.bool("REFRESH_TEST_DATABASE", default=True)
LONG_OVERDUE = env.int("LONG_OVERDUE", default=14)
MEDIUM_OVERDUE = env.int("MEDIUM_OVERDUE", default=7)
ICONS = env.list("ICONS")
TOGGL_API_TOKEN = env("TOGGL_API_TOKEN")
#: Working hours
HOME_HOURS = env.int("HOME_HOURS")
#: How many minutes before the reminder should be set
