Python Env Variables: os.environ, dotenv & Pydantic

import os

# Raises KeyError if DATABASE_URL is not set
db_url = os.environ['DATABASE_URL']

# Returns None if missing — no exception
db_url = os.getenv('DATABASE_URL')

# Returns a fallback value if missing
db_url = os.getenv('DATABASE_URL', 'sqlite:///local.db')

# You can also use .get() on os.environ directly
db_url = os.environ.get('DATABASE_URL', 'sqlite:///local.db')

# Set a variable for the current process
os.environ['APP_MODE'] = 'debug'

from dotenv import load_dotenv
import os

# Load .env from the current working directory
load_dotenv()

# Or specify an explicit path
load_dotenv('/app/config/.env')

# By default, existing env vars are NOT overridden.
# Pass override=True to replace existing values.
load_dotenv(override=True)

# Now read variables normally
secret_key = os.getenv('SECRET_KEY')

from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    database_url: str
    debug: bool = False
    max_connections: int = 10
    allowed_hosts: list[str] = ['localhost']

    model_config = {
        'env_file': '.env',
        'env_file_encoding': 'utf-8',
    }

# Pydantic reads DATABASE_URL, DEBUG, MAX_CONNECTIONS from the environment,
# converts them to the annotated types, and validates them.
settings = Settings()

print(settings.debug)            # bool, not str
print(settings.max_connections)  # int, not str

# settings.py
import environ

env = environ.Env(
    DEBUG=(bool, False),
    ALLOWED_HOSTS=(list, ['localhost']),
)

# Read the .env file
environ.Env.read_env('.env')

SECRET_KEY = env('SECRET_KEY')
DEBUG = env('DEBUG')                          # bool
ALLOWED_HOSTS = env('ALLOWED_HOSTS')          # list
DATABASES = {
    'default': env.db('DATABASE_URL'),        # parses database URLs
}
CACHES = {
    'default': env.cache('CACHE_URL'),        # parses cache URLs
}
EMAIL_CONFIG = env.email('EMAIL_URL')         # parses email URLs

from dotenv import load_dotenv
load_dotenv()

from flask import Flask
import os

app = Flask(__name__)

# Option 1: read individual vars
app.config['SECRET_KEY'] = os.environ['SECRET_KEY']
app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL')

# Option 2: load all FLASK_ prefixed vars (strips the prefix)
# FLASK_SECRET_KEY in .env becomes app.config['SECRET_KEY']
app.config.from_prefixed_env()

# Option 3: load from a config object
class Config:
    SECRET_KEY = os.environ['SECRET_KEY']
    SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL', 'sqlite:///app.db')
    DEBUG = os.getenv('FLASK_DEBUG', 'false').lower() == 'true'

app.config.from_object(Config)

# These are NOT set by activating a venv — they come from the shell
os.getenv('DATABASE_URL')  # inherited from parent process
os.getenv('VIRTUAL_ENV')   # set by the activate script

# To set env vars per-project, use a .env file with python-dotenv
# or export them in the activate script:
# echo 'export DATABASE_URL=postgres://...' >> .venv/bin/activate

import os

# A subprocess or C extension mutated the real environment after startup.
# os.environ still holds the snapshot from interpreter start:
os.getenv('FEATURE_FLAG')  # stale — may be None even though it's now set

# Python 3.14+ only: re-read the live OS environment into os.environ
os.reload_environ()
os.getenv('FEATURE_FLAG')  # now reflects the current process environment

# Gotcha: assigning through os.environ DOES propagate (it calls putenv);
# calling os.putenv() directly does NOT update os.environ.
os.putenv('X', '1')        # os.environ still has no 'X'
os.environ['X'] = '1'      # this both sets the OS var and updates the cache

import os

# BUG: bool('false') is True — any non-empty string is truthy
debug = bool(os.getenv('DEBUG', 'false'))  # True!

# Correct: compare the string value
debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')

# Integers
max_conn = int(os.getenv('MAX_CONNECTIONS', '10'))

# Floats
timeout = float(os.getenv('TIMEOUT_SECONDS', '30.0'))

# Lists (common convention: comma-separated)
hosts = os.getenv('ALLOWED_HOSTS', 'localhost').split(',')

# Use Pydantic Settings to avoid manual conversion entirely

import os
import sys

# Optional with default
log_level = os.getenv('LOG_LEVEL', 'INFO')

# Required — crash immediately with a clear message
database_url = os.environ.get('DATABASE_URL')
if not database_url:
    sys.exit('DATABASE_URL environment variable is required')

# Required — one-liner using os.environ (raises KeyError)
secret_key = os.environ['SECRET_KEY']

# With Pydantic: fields without defaults are required
from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    secret_key: str              # required — ValidationError if missing
    debug: bool = False          # optional with default
    log_level: str = 'INFO'      # optional with default

# pytest — monkeypatch (recommended)
def test_database_config(monkeypatch):
    monkeypatch.setenv('DATABASE_URL', 'sqlite:///test.db')
    monkeypatch.setenv('DEBUG', 'true')

    from myapp.config import get_settings
    settings = get_settings()
    assert settings.debug is True

def test_missing_var(monkeypatch):
    monkeypatch.delenv('SECRET_KEY', raising=False)
    # Test that your app raises on missing required vars

# unittest — mock.patch.dict
from unittest.mock import patch

@patch.dict('os.environ', {'API_KEY': 'test-key-123'})
def test_api_client():
    import os
    assert os.environ['API_KEY'] == 'test-key-123'

@patch.dict('os.environ', {}, clear=True)
def test_empty_environment():
    import os
    assert os.getenv('DATABASE_URL') is None