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