from environs import Env
env = Env()
DEBUG = env.bool('DEBUG', default=True)
BIND_HOST = env('BIND_HOST', default='127.0.0.1')
BIND_PORT = env.int('BIND_PORT', default=5000)
NEO4J_HOST = env('NEO4J_HOST', default='localhost')
NEO4J_PORT = env.int('NEO4J_PORT', default=7687)
NEO4J_USER = env('NEO4J_USER', default='neo4j')
NEO4J_PASSWORD = env('NEO4J_PASSWORD', default='admin')
flask_config_mapping = {
"BIND_HOST": BIND_HOST,
"BIND_PORT": BIND_PORT,
"NEO4J_HOST": NEO4J_HOST,
"NEO4J_PORT": NEO4J_PORT,
"NEO4J_USER": NEO4J_USER,
"NEO4J_PASSWORD": NEO4J_PASSWORD
}
},
},
]
WSGI_APPLICATION = 'dll.configuration.wsgi.application'
# Database
# https://docs.djangoproject.com/en/2.2/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': env.str('DATABASE_NAME'),
'USER': env.str('DATABASE_USER'),
'HOST': env.str('DATABASE_HOST'),
'PORT': env.int('DATABASE_PORT', 5432),
}
}
if env.str('DATABASE_PASSWORD', None):
DATABASES['default']['PASSWORD'] = env.str('DATABASE_PASSWORD')
# Password validation
# https://docs.djangoproject.com/en/2.2/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME':
'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME':
DEBUG = env.bool('DEBUG', default=False)
LOG_LEVEL = env.log_level('LOG_LEVEL', 'INFO')
BROKER_REDIS_URL = env('BROKER_REDIS_URL', 'redis://127.0.0.1:6379/0')
RESULT_REDIS_URL = env('RESULT_REDIS_URL', 'redis://127.0.0.1:6379/1')
RATE_LIMITS_REDIS_URL = env(
'RATE_LIMITS_REDIS_URL',
'redis://127.0.0.1:6379/2',
)
SNAKE_API_ADDRESS = env('SNAKE_API_ADDRESS', 'http://localhost:8080/api')
SNAKE_CLIENT_URL = env('SNAKE_CLIENT_URL', 'http://localhost:8080/client/')
CLIENT_NAME = env('CLIENT_NAME', 'SnakeCLIClient')
TASK_INTERVAL_SCREENSHOT = env.int('TASK_INTERVAL_SCREENSHOT', 60)
TASK_INTERVAL_DELETE_CACHE = env.int('TASK_INTERVAL_DELETE_CACHE', 3600)
# Prometheus
PROMETHEUS_METRICS_LISTEN_HOST = env(
'PROMETHEUS_METRICS_LISTEN_HOST',
"0.0.0.0",
)
PROMETHEUS_METRICS_LISTEN_PORT = env.int(
'PROMETHEUS_METRICS_LISTEN_PORT',
9191,
)
PROMETHEUS_METRICS_SERVER_ENABLE = env.bool(
"PROMETHEUS_METRICS_SERVER_ENABLE",
False,
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__))
ENV = env("ENVIRONMENT", default="local")
if ENV not in ("local", "dev", "staging", "production"):
warnings.warn(
"ENVIRONMENT env variable must be one of local, dev, staging or production"
)
DEBUG = env("DEBUG", default=False)
SECRET_KEY = env("DJANGO_SECRET_KEY", default=get_random_secret_key())
HOSTED_SEATS_LIMIT = env.int("HOSTED_SEATS_LIMIT", default=0)
# Google Analytics Configuration
GOOGLE_ANALYTICS_KEY = env("GOOGLE_ANALYTICS_KEY", default="")
GOOGLE_SERVICE_ACCOUNT = env("GOOGLE_SERVICE_ACCOUNT", default=None)
if not GOOGLE_SERVICE_ACCOUNT:
warnings.warn(
"GOOGLE_SERVICE_ACCOUNT not configured, getting organisation usage will not work"
)
GA_TABLE_ID = env("GA_TABLE_ID", default=None)
if not GA_TABLE_ID:
warnings.warn(
"GA_TABLE_ID not configured, getting organisation usage will not work")
INFLUXDB_TOKEN = env.str("INFLUXDB_TOKEN", default="")
INFLUXDB_BUCKET = env.str("INFLUXDB_BUCKET", default="")
"320px",
"width":
"960px",
"menubar":
"file edit view insert format tools table help",
"plugins":
"advlist autolink lists link image charmap print preview anchor searchreplace visualblocks code "
"fullscreen insertdatetime media table paste code help wordcount spellchecker",
"toolbar":
"undo redo | bold italic underline strikethrough | fontselect fontsizeselect formatselect | alignleft "
"aligncenter alignright alignjustify | outdent indent | numlist bullist checklist | forecolor "
"backcolor casechange permanentpen formatpainter removeformat | pagebreak | charmap emoticons | "
"fullscreen preview save print | insertfile image media pageembed template link anchor codesample | "
"a11ycheck ltr rtl | showcomments addcomment code",
"custom_undo_redo_levels":
10,
}
# Security
CSRF_COOKIE_SECURE = env.bool("CSRF_COOKIE_SECURE", default=False)
SESSION_COOKIE_SECURE = env.bool("SESSION_COOKIE_SECURE", default=False)
# HTTP Strict Transport Security settings
SECURE_HSTS_SECONDS = env.int("SECURE_HSTS_SECONDS", default=0)
SECURE_HSTS_INCLUDE_SUBDOMAINS = env.bool("SECURE_HSTS_INCLUDE_SUBDOMAINS",
default=False)
SECURE_HSTS_PRELOAD = env.bool("SECURE_HSTS_PRELOAD", default=False)
SECURE_SSL_REDIRECT = env.bool("SECURE_SSL_REDIRECT", default=False)
# -*- 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")
SEND_FILE_MAX_AGE_DEFAULT = env.int("SEND_FILE_MAX_AGE_DEFAULT")
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
import rpyc
from environs import Env
env = Env()
env.read_env()
JARVIS_HOST = env.str('JARVIS_HOST', default='localhost')
JARVIS_PORT = env.int('JARVIS_PORT', default=54321)
class JarvisClient(object):
def __init__(self, hostname='localhost', port=54321):
self.conn = rpyc.connect(hostname, port)
def sms_admin(self, message, from_app=None):
return self.conn.root.sms_admin(message, from_app)
def telegram_jarvis(self, message, from_app=None):
return self.conn.root.telegram_jarvis(message, from_app)
jarvis = JarvisClient(port=JARVIS_PORT, hostname=JARVIS_HOST)
if __name__ == '__main__':
client = JarvisClient(port=54321)
client.telegram_jarvis('test message!')
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')
LGSVL__RANDOM_SEED Seed used to determine random factors (e.g. NPC type, color, behaviour)
LGSVL__SIMULATION_DURATION_SECS How long to run the simulation for
LGSVL__SIMULATOR_HOST IP address of computer running simulator (Master node if a cluster)
LGSVL__SIMULATOR_PORT Port that the simulator allows websocket connections over
LGSVL__SPAWN_BICYCLES Wether or not to spawn bicycles
LGSVL__SPAWN_PEDESTRIANS Whether or not to spawn pedestrians
LGSVL__SPAWN_TRAFFIC Whether or not to spawn NPC vehicles
LGSVL__TIME_OF_DAY If LGSVL__DATE_TIME is not set, today's date is used and this sets the time of day to start simulation at, clamped to [0, 24]
LGSVL__TIME_STATIC Whether or not time should remain static (True = time is static, False = time moves forward)
LGSVL__VEHICLE_0 Name of EGO vehicle to be loaded in Simulator
'''
env = Env()
sim = lgsvl.Simulator(env.str("LGSVL__SIMULATOR_HOST", "127.0.0.1"),
env.int("LGSVL__SIMULATOR_PORT", 8181))
scene_name = env.str("LGSVL__MAP", lgsvl.wise.DefaultAssets.map_borregasave)
try:
sim.load(scene_name, env.int("LGSVL__RANDOM_SEED"))
except Exception:
if sim.current_scene == scene_name:
sim.reset()
else:
sim.load(scene_name)
def clamp(val, min_v, max_v):
return min(max(val, min_v), max_v)
try:
# TODO (√)DEPLOY_INTERVAL -- schedule任务间隔
# 定时任务中采集任务频次： 1轮/INTERVAL_ACTION
# Defaults type:int = 60 minutes
#
# 定时任务中数据备份频次： 1轮/INTERVAL_REFRESH
# Defaults type:int = 10 minutes
# ---------------------------------------------------
LAUNCH_INTERVAL = {"action": 60, "refresh": 1}
# ---------------------------------------------------
# TODO (√)Redis Cluster Configuration(SSH-BASE)
# 若您不知道如何配置Redis远程连接，请自行搜索或↓
# https://shimo.im/docs/5bqnroJYDbU4rGqy/
# ---------------------------------------------------
REDIS_GENERAL_DR = env.bool("REDIS_GENERAL_DR", True)
REDIS_GENERAL_DB = env.int("REDIS_GENERAL_DB", 0)
# TODO (√)Settings of the Master-Redis responsible for leading the workflow
REDIS_MASTER = {
"host": "",
"password": "",
"port": 6379,
"db": 0,
}
# TODO (*)Setting of the Slave-Redis responsible for data disaster tolerance（DDT）
REDIS_SLAVER_DDT = {
# If you do not have extra servers, please use stand-alone backup
# 'host': REDIS_MASTER['host'],
# 'db': REDIS_MASTER['db'] + 1,
"host": "",
"password": "",
from environs import Env
_env = Env()
LOG_LEVEL = _env.log_level("LOG_LEVEL", default="INFO")
REDIS_HOST = _env.str("REDIS_HOST", default="localhost")
REDIS_PORT = _env.int("REDIS_PORT", default=6379)
REDIS_PASSWORD = _env.str("REDIS_PASSWORD", default=None)
RABBIT_HOST = _env.str("RABBIT_HOST", default="localhost")
PG_HOST = _env.str("POSTGRES_HOST", default="localhost")
PG_PORT = _env.int("POSTGRES_PORT", default=5432)
PG_DB = _env.str("POSTGRES_DATABASE", default="billing")
PG_USER = _env.str("POSTGRES_USER", default="postgres")
PG_PASSWORD = _env.str("POSTGRES_PASSWORD", default="postgres")
QUEUE_NAME_PREFIX = _env.str("QUEUE_NAME_PREFIX", default="billing")
QUEUES_COUNT = _env.int("QUEUES_COUNT", default=3)
QUEUE_INDEX = _env.int("QUEUE_INDEX", default=None)
BASE_DIR = Path(__file__).resolve(strict=True).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("DJANGO_SECRET_KEY")
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = env.bool("DJANGO_DEBUG", default=False)
ALLOWED_HOSTS = ['.herokuapp.com', 'localhost', '127.0.0.1']
SECURE_SSL_REDIRECT = env.bool("DJANGO_SECURE_SSL_REDIRECT", default=True)
SECURE_HSTS_SECONDS = env.int("DJANGO_SECURE_HSTS_SECONDS", default=2592000)
SECURE_HSTS_INCLUDE_SUBDOMAINS = env.bool(
"DJANGO_SECURE_HSTS_INCLUDE_SUBDOMAINS", default=True)
SECURE_HSTS_PRELOAD = env.bool("DJANGO_SECURE_HSTS_PRELOAD", default=True)
SESSION_COOKIE_SECURE = env.bool("DJANGO_SESSION_COOKIE_SECURE", default=True)
CSRF_COOKIE_SECURE = env.bool("DJANGO_CSRF_COOKIE_SECURE", default=True)
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
REST_FRAMEWORK = {
# Use Django's standard `django.contrib.auth` permissions,
# or allow read-only access for unauthenticated users.
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly',
'rest_framework.permissions.IsAuthenticated',
],
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework.authentication.SessionAuthentication',
'rest_framework.authentication.TokenAuthentication',
),
'DEFAULT_PAGINATION_CLASS':
'rest_framework.pagination.LimitOffsetPagination',
'PAGE_SIZE':
env.int('DOCCANO_PAGE_SIZE', default=5),
'DEFAULT_FILTER_BACKENDS':
('django_filters.rest_framework.DjangoFilterBackend', ),
'SEARCH_PARAM':
'q',
'DEFAULT_RENDERER_CLASSES':
('rest_framework.renderers.JSONRenderer',
'rest_framework.renderers.BrowsableAPIRenderer',
'rest_framework_xml.renderers.XMLRenderer')
}
# Internationalization
# https://docs.djangoproject.com/en/2.0/topics/i18n/
LANGUAGE_CODE = 'en-us'
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)
import multiprocessing
from Flask import app
from get_ter import Getter
from get_test import Tester
import platform
from environs import Env
env = Env()
env.read_env()
TESTER_CYCLE = 20
GETTER_CYCLE = 20
TESTER_ENABLED = True
GETTER_ENABLED = True
API_ENABLED = True
API_HOST = env.str('API_HOST', '127.0.0.1')
API_PORT = env.int('API_PORT', 5000)
API_THREADED = env.bool('API_THREADED', True)
IS_WINDOWS = platform.system().lower() == 'windows'
if IS_WINDOWS:
multiprocessing.freeze_support()
class Scheduler():
def schedule_tester(self, cycle=TESTER_CYCLE):
"""
定时测试代理
"""
tester = Tester()
while True:
print('测试器开始运行')
tester.run()
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())
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()
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 = [
-9.9, 2, -9.9, 0.0, -9.9, -9.9, 0.0, 450.0, 1.0, -9.9, 0.0, -9.9,
1.0
]
values = ListValue(values=[Value(number_value=x) for x in data])
values = Value(list_value=values)
num_values = ListValue(values=[values for _ in range(DATA_SIZE)])
data = [
'05db9164', '08d6d899', '77f2f2e5', 'd16679b9', '25c83c98',
'7e0ccccf', 'af0809a5', '5b392875', '7cc72ec2', '3b08e48b',
'9e12e146', '9f32b866', '025225f2', '07d13a8f', '41f10449',
'31ca40b6', '2005abd1', '698d1c68', '', '', 'dfcfc3fa', '',
'be7c41b4', 'aee52b6f', '', ''
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())
self.database = database
self.collections = collections
Cfg = Config
p = Path(".") / ".env"
env = Env()
env.read_env(p / ".env", recurse=False)
with env.prefixed("BKP_MONGO_"):
ENV = env("ENV")
if ENV == "production":
env.read_env(p / ".env.production", recurse=False)
elif ENV == "staging":
env.read_env(p / ".env.staging", recurse=False)
elif ENV == "development":
env.read_env(p / ".env.development", recurse=False)
elif ENV == "test":
env.read_env(p / ".env.test", recurse=False)
else:
pass
Cfg.usr = env("USR")
Cfg.pwd = env("PWD")
Cfg.url = env("URL")
Cfg.port = env.int("PORT", 27017)
Cfg.database = env("DATABASE")
Cfg.collections = env("COLLECTIONS")
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, 25mph)
SPEED_VARIANCE = 4
TIME_LIMIT = 15 # seconds
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("PLC_B_25 - ", end='')
sim = lgsvl.Simulator(LGSVL__SIMULATOR_HOST, LGSVL__SIMULATOR_PORT)
scene_name = env.str("LGSVL__MAP",
lgsvl.wise.DefaultAssets.map_straight2lanesame)
if sim.current_scene == scene_name:
sim.reset()
else:
sim.load(scene_name)
# spawn EGO in the 2nd to right lane
egoState = lgsvl.AgentState()
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()
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')
# -*- coding: utf-8 -*-
"""Application configuration.
Most configuration is set via environment variables.
For local development, use a .env file to set
environment variables.
"""
import os
from environs import Env
env = Env()
env.read_env()
ENV = env.str("FLASK_ENV", default="production")
DEBUG = ENV == "development"
SQLALCHEMY_DATABASE_URI = (
os.environ.get('DEV_DATABASE_URL')
or 'postgresql://[email protected]:5432/flaskdeliveryapp')
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"
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
URI = 'mysql+pymysql://{0}:{1}@{2}:{3}/{4}'.format(
os.environ.get("DB_USERNAME"), os.environ.get("DB_PASSWORD"),
os.environ.get("DB_HOST"), os.environ.get("DB_PORT"),
os.environ.get("DB_NAME"))
env = Env()
env.read_env()
ENV = env.str('FLASK_ENV', default='settings.dev_settings')
DEBUG = ENV == 'development'
SQLALCHEMY_DATABASE_URI = URI
SECRET_KEY = '(1#p1r1xt_^%2-)yc=$6f+olxszb1xzmm_phx_#bnt&nn)j!c7'
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'
# REDIS_URL = "redis://0.0.0.0:6379/0"
# REDIS_URL = env.str('REDIS_URL', None)
# JWT settings
JWT_SECRET_KEY = SECRET_KEY
JWT_ACCESS_TOKEN_EXPIRES = datetime.timedelta(days=7)
# JWT_ACCESS_COOKIE_PATH = "api/"
JWT_TOKEN_LOCATION = ['cookies']
JWT_ERROR_MESSAGE_KEY = "message"
JWT_ACCESS_COOKIE_NAME = "x-access-token"
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)
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:
print(err)
#
# This software contains code licensed as described in LICENSE.
#
import math
import random
from environs import Env
import lgsvl
print("Python API Quickstart #98: Simulating different NPCs behaviours")
env = Env()
sim = lgsvl.Simulator(
env.str("LGSVL__SIMULATOR_HOST",
lgsvl.wise.SimulatorSettings.simulator_host),
env.int("LGSVL__SIMULATOR_PORT",
lgsvl.wise.SimulatorSettings.simulator_port))
drunkDriverAvailable = False
trailerAvailable = 0
print("Current Scene = {}".format(sim.current_scene))
# Loads the named map in the connected simulator.
if sim.current_scene == lgsvl.wise.DefaultAssets.map_cubetown:
sim.reset()
else:
print("Loading Scene = {}".format(lgsvl.wise.DefaultAssets.map_cubetown))
sim.load(lgsvl.wise.DefaultAssets.map_cubetown)
agents = sim.available_agents
print("agents:")
for i in range(len(agents)):
#!/usr/bin/env python3
#
# Copyright (c) 2019-2020 LG Electronics, Inc.
#
# This software contains code licensed as described in LICENSE.
#
from environs import Env
import lgsvl
env = Env()
sim = lgsvl.Simulator(env.str("LGSVL__SIMULATOR_HOST", "127.0.0.1"),
env.int("LGSVL__SIMULATOR_PORT", 8181))
if sim.current_scene == "BorregasAve":
sim.reset()
else:
sim.load("BorregasAve")
spawns = sim.get_spawn()
state = lgsvl.AgentState()
state.transform = spawns[0]
ego = sim.add_agent(env.str("LGSVL__VEHICLE_0", "Lincoln2017MKZ (Apollo 5.0)"),
lgsvl.AgentType.EGO, state)
# get_sensors returns a list of sensors on the EGO vehicle
sensors = ego.get_sensors()
for s in sensors:
if s.name == "Main Camera":
# Camera and LIDAR sensors can save data to the specified file path
"""PGSync Settings."""
import logging
import logging.config
from environs import Env
logger = logging.getLogger(__name__)
env = Env()
env.read_env()
# PGSync:
# path to the application schema config
SCHEMA = env.str('SCHEMA', default=None)
# db query chunk size (how many records to fetch at a time)
QUERY_CHUNK_SIZE = env.int('QUERY_CHUNK_SIZE', default=10000)
# poll db interval (consider reducing this duration to increase throughput)
POLL_TIMEOUT = env.float('POLL_TIMEOUT', default=0.1)
# replication slot cleanup interval (in secs)
REPLICATION_SLOT_CLEANUP_INTERVAL = env.float(
'REPLICATION_SLOT_CLEANUP_INTERVAL',
default=3600.0,
)
# Elasticsearch:
ELASTICSEARCH_SCHEME = env.str('ELASTICSEARCH_SCHEME', default='http')
ELASTICSEARCH_HOST = env.str('ELASTICSEARCH_HOST', default='localhost')
ELASTICSEARCH_PORT = env.int('ELASTICSEARCH_PORT', default=9200)
ELASTICSEARCH_USER = env.str('ELASTICSEARCH_USER', default=None)
ELASTICSEARCH_PASSWORD = env.str('ELASTICSEARCH_PASSWORD', default=None)
# increase this if you are getting read request timeouts
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.0/howto/static-files/
STATIC_URL = '/static/'
LOGIN_URL = '/login/'
LOGIN_REDIRECT_URL = '/projects/'
LOGOUT_REDIRECT_URL = '/'
# Change 'default' database configuration with $DATABASE_URL.
DATABASES['default'].update(dj_database_url.config(
env='DATABASE_URL',
conn_max_age=env.int('DATABASE_CONN_MAX_AGE', 500),
ssl_require='sslmode' not in furl(env('DATABASE_URL', '')).args,
))
# Honor the 'X-Forwarded-Proto' header for request.is_secure()
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
# Allow all host headers
# ALLOWED_HOSTS = ['*']
# Size of the batch for creating documents
# on the import phase
IMPORT_BATCH_SIZE = 500
GOOGLE_TRACKING_ID = env('GOOGLE_TRACKING_ID', 'UA-125643874-2')
USE_TZ = True
TEST_RUNNER = "xmlrunner.extra.djangotestrunner.XMLTestRunner"
TEST_OUTPUT_DIR = str(BASE_PATH / "junitxml")
LOGIN_URL = "/login/"
LOGIN_REDIRECT_URL = "/app/"
LOGOUT_REDIRECT_URL = "/"
django_heroku.settings(locals(), test_runner=False)
# Change 'default' database configuration with $DATABASE_URL.
DATABASES["default"].update(
dj_database_url.config(
env="DATABASE_URL",
conn_max_age=env.int("DATABASE_CONN_MAX_AGE", 500),
ssl_require="sslmode" not in furl(env("DATABASE_URL", "")).args,
))
# work-around for dj-database-url: explicitly disable ssl for sqlite
if DATABASES["default"].get("ENGINE") == "django.db.backends.sqlite3":
DATABASES["default"].get("OPTIONS", {}).pop("sslmode", None)
# Honor the 'X-Forwarded-Proto' header for request.is_secure()
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
# Allow all host headers
# ALLOWED_HOSTS = ['*']
# Size of the batch for creating documents
# on the import phase
# 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', '')
# redis port
REDIS_PORT = env.int('REDIS_PORT', 6379)
# redis password, if no password, set it to None
REDIS_PASSWORD = env.str('REDIS_PASSWORD', '')
# redis db, if no choice, set it to 0
REDIS_DB = env.int('REDIS_DB', 0)
# redis connection string, like redis://[password]@host:port or rediss://[password]@host:port/0
REDIS_CONNECTION_STRING = env.str('REDIS_CONNECTION_STRING', None)
if REDIS_CONNECTION_STRING:
REDIS_HOST, REDIS_PORT, REDIS_PASSWORD, REDIS_DB = parse_redis_connection_string(
REDIS_CONNECTION_STRING)
# redis hash table key name
REDIS_KEY = env.str('REDIS_KEY', 'proxies:universal')
# definition of proxy scores
# -*- 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")
SEND_FILE_MAX_AGE_DEFAULT = env.int("SEND_FILE_MAX_AGE_DEFAULT")
BCRYPT_LOG_ROUNDS = env.int("BCRYPT_LOG_ROUNDS", default=13)
DEBUG_TB_ENABLED = False#DEBUG
DEBUG_TB_INTERCEPT_REDIRECTS = False
CACHE_TYPE = "simple" # Can be "memcached", "redis", etc.
SQLALCHEMY_TRACK_MODIFICATIONS = False
GOOGLE_APPLICATION_CREDENTIALS=env.str("GOOGLE_APPLICATION_CREDENTIALS")
MAIL_SERVER = env.str("MAIL_SERVER")
MAIL_PORT = env.int("BCRYPT_LOG_ROUNDS", default=587)
MAIL_USE_TLS = env.int("MAIL_USE_TLS", default=1)
MAIL_USERNAME = env.str("MAIL_USERNAME")
MAIL_PASSWORD = env.str("MAIL_PASSWORD")
MAIL_DEFAULT_SENDER = env.str("MAIL_DEFAULT_SENDER")
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
SECURITY_USER_IDENTITY_ATTRIBUTES = 'username'
SECURITY_CLI_USERS_NAME = False
SECURITY_CLI_ROLES_NAME = False
IATI_DATA_PATH = env.str('IATI_DATA_PATH',
default=join(dirname(dirname(basedir)), 'org_xml'))
IATI_RESULT_PATH = env.str('IATI_RESULT_PATH',
with open(index_path, 'w', encoding="utf8") as file:
file.write(render)
if __name__ == '__main__':
template_link = "template.html"
index_link = "index{}.html"
env_vars = Env()
env_vars.read_env()
parser = create_parser()
namespace = parser.parse_args()
host = env_vars("HOST",
DEFAULT_HOST) if namespace.host is None else namespace.host
port = env_vars.int(
"PORT", DEFAULT_PORT) if namespace.port is None else namespace.port
books_path = env_vars(
"JSON_FILE", DEFAULT_JSON_PATH
) if namespace.json_path is None else namespace.json_path
with open(books_path, "r", encoding="utf-8") as file:
books = load(file)
env = Environment(loader=FileSystemLoader('.'),
autoescape=select_autoescape(['html', 'xml']))
server = Server()
server.watch(template_link,
lambda: on_reload(books, template_link, index_link))
server.serve(root='.', host=host, port=port)
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'),
})
from environs import Env
from sendgrid import SendGridAPIClient
from sendgrid.helpers.mail import Mail
env = Env()
env.read_env()
DM_BIRTHDAY_FILE = env('DM_BIRTHDAY_FILE')
DM_GITHUB_EDIT = env('DM_GITHUB_EDIT')
DM_FINNHUB_TOKEN = env('DM_FINNHUB_TOKEN')
DM_SENDGRID_TOKEN = env('DM_SENDGRID_TOKEN')
DM_FROM_EMAIL = env("DM_FROM_EMAIL")
DM_TO_EMAILS = env.list("DM_TO_EMAILS")
DM_IEX_TOKEN = env('DM_IEX_TOKEN')
DM_IEX_SERVER = env('DM_IEX_SERVER')
DM_XDAYS = env.int('DM_XDAYS')
def load_csvfile(filename):
bd = []
with open(filename, newline='') as f:
reader = csv.DictReader(f)
for row in reader:
bd.append(row)
return bd
def parse_dates(bd):
for i, val in enumerate(bd):
datee = datetime.datetime.strptime(val['birthday'], "%Y-%m-%d")
bd[i]['day'] = datee.day
bd[i]['month'] = datee.month
bd[i]['year'] = datee.year
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',
]
MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'corsheaders.middleware.CorsMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'django.middleware.cache.FetchFromCacheMiddleware',
]
CACHE_MIDDLEWARE_SECONDS = env.int("CACHE_SECONDS", 1)
CORS_ORIGIN_ALLOW_ALL = True
REST_FRAMEWORK = {
# Use Django's standard `django.contrib.auth` permissions,
# or allow read-only access for unauthenticated users.
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework_simplejwt.authentication.JWTAuthentication',
'rest_framework.authentication.SessionAuthentication'
],
'DEFAULT_PERMISSION_CLASSES':
['rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly']
}
ROOT_URLCONF = 'config.urls'
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'
ENV_TYPE = None
def get_env():
if 'HALO_STAGE' in os.environ:
# -*- 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
