Configuration management in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the BaseSettings class from Pydantic for configuration.

FastAPI

from pydantic import [1]

Drag options to blanks, or click blank then click option'

AConfig

BBaseSettings

CField

DBaseModel

Attempts:

3 left

💡 Hint

Common Mistakes

Importing BaseModel instead of BaseSettings

Using Field which is for defining fields, not settings

Trying to import a non-existent Config class

The BaseSettings class from Pydantic is used to define configuration classes that read environment variables automatically.

2fill in blank

medium

Complete the code to define a configuration class that reads the app name from environment variables.

FastAPI

class Settings(BaseSettings):
    app_name: str = [1]

Drag options to blanks, or click blank then click option'

A"DefaultApp"

B"MyApp"

C"AppName"

D"FastAPI App"

Attempts:

3 left

💡 Hint

Common Mistakes

Leaving the value empty

Using a variable name instead of a string

Using incorrect quotes

The default value for app_name is set to "FastAPI App" here, which will be used if no environment variable overrides it.

3fill in blank

hard

Fix the error in the code to create a singleton settings instance for reuse.

FastAPI

def get_settings():
    if not hasattr(get_settings, "_settings"):
        get_settings._settings = [1]()
    return get_settings._settings

Drag options to blanks, or click blank then click option'

ASettings

BBaseSettings

CConfig

DSettingsConfig

Attempts:

3 left

💡 Hint

Common Mistakes

Using BaseSettings directly which is a base class

Using a non-existent class name

Forgetting to instantiate the class

The function creates a single instance of the Settings class and reuses it to avoid recreating settings multiple times.

4fill in blank

hard

Fill both blanks to load environment variables from a .env file using Pydantic settings.

FastAPI

class Settings(BaseSettings):
    class Config:
        env_file = [1]
        env_file_encoding = [2]

Drag options to blanks, or click blank then click option'

A".env"

B"utf-8"

C"config.env"

D"ascii"

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong file names like "config.env"

Using incorrect encoding like "ascii"

Omitting the quotes around strings

The env_file is set to ".env" to load environment variables from that file, and env_file_encoding is set to "utf-8" to properly read the file encoding.

5fill in blank

hard

Fill all three blanks to create a FastAPI app that uses dependency injection to get settings.

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

@app.get("/")
async def read_root(settings: Settings = Depends([1])):
    return {"app_name": settings.[2]

settings_instance = [3]()

Drag options to blanks, or click blank then click option'

Aget_settings

Bapp_name

CSettings

DSettingsConfig

Attempts:

3 left

💡 Hint

Common Mistakes

Using the class name instead of the function in Depends

Accessing a wrong attribute name

Instantiating a wrong class

The endpoint uses FastAPI's Depends to inject the singleton settings instance returned by get_settings. The response returns the app_name attribute from the settings. The settings_instance is created by instantiating the Settings class.

Practice

1. What is the primary purpose of using pydantic.BaseSettings in a FastAPI application?

easy

A. To generate API documentation

B. To manage application configuration using environment variables or .env files

C. To handle HTTP request routing

D. To create database models automatically

Solution

1. Step 1: Understand the role of pydantic.BaseSettings

   BaseSettings is designed to load configuration values from environment variables or .env files.

2. Step 2: Differentiate from other FastAPI features

   Database models, routing, and documentation are handled by other parts of FastAPI, not BaseSettings.

3. Final Answer:

   To manage application configuration using environment variables or .env files -> Option B

4. Quick Check:

   Configuration management = To manage application configuration using environment variables or .env files [OK]

Hint: Remember: BaseSettings is for config, not routing or DB [OK]

Common Mistakes:

• Confusing BaseSettings with database model classes
• Thinking BaseSettings handles API routing
• Assuming BaseSettings generates docs

2. Which of the following is the correct way to define a FastAPI settings class using pydantic.BaseSettings?

easy

A. def Settings(): return BaseSettings(app_name="MyApp")

B. class Settings: app_name = BaseSettings("MyApp")

C. class Settings(BaseModel): app_name: str = "MyApp"

D. class Settings(BaseSettings): app_name: str = "MyApp"

Solution

1. Step 1: Check class inheritance

   The settings class must inherit from BaseSettings to load environment variables.

2. Step 2: Verify attribute definition

   Attributes are defined as class variables with type annotations and default values.

3. Final Answer:

   class Settings(BaseSettings): app_name: str = "MyApp" -> Option D

4. Quick Check:

   Correct inheritance and attribute syntax = class Settings(BaseSettings): app_name: str = "MyApp" [OK]

Hint: Settings class must inherit BaseSettings with typed attributes [OK]

Common Mistakes:

• Using BaseModel instead of BaseSettings
• Defining settings as a function
• Incorrect inheritance or attribute assignment

3. Given this settings class and environment variable API_KEY=secret123 set, what will print(settings.api_key) output?

from pydantic import BaseSettings

class Settings(BaseSettings):
    api_key: str

settings = Settings()

medium

A. '' (empty string)

B. None

C. secret123

D. Raises a validation error

Solution

1. Step 1: Understand environment variable loading

   BaseSettings automatically reads environment variables matching attribute names in uppercase.

2. Step 2: Check if API_KEY is set

   The environment variable API_KEY=secret123 is set, so settings.api_key will be 'secret123'.

3. Final Answer:

   secret123 -> Option C

4. Quick Check:

   Env var API_KEY loads as 'secret123' [OK]

Hint: BaseSettings reads uppercase env vars matching attribute names [OK]

Common Mistakes:

• Assuming missing default means None instead of error
• Thinking attribute names are case-sensitive differently
• Expecting empty string if env var is set

4. Identify the error in this FastAPI settings code snippet:

from pydantic import BaseSettings

class Settings(BaseSettings):
    debug: bool = False

settings = Settings(debug="foo")

medium

A. Passing a string "foo" instead of a boolean causes a validation error

B. Missing environment variable causes failure

C. BaseSettings cannot have default values

D. Class must inherit from BaseModel, not BaseSettings

Solution

1. Step 1: Check type of passed value

   The debug attribute expects a boolean, but the code passes a string "foo".

2. Step 2: Understand Pydantic validation

   Pydantic tries to coerce the string to bool but "foo" is not recognized, causing a ValidationError.

3. Final Answer:

   Passing a string "foo" instead of a boolean causes a validation error -> Option A

4. Quick Check:

   Pydantic rejects invalid bool strings like "foo" [OK]

Hint: Pydantic bool fields reject invalid strings like "foo" [OK]

Common Mistakes:

• Thinking Pydantic converts any string to bool
• Missing environment variable causes failure
• BaseSettings cannot have default values

5. You want to load configuration from a .env file and override some values with environment variables in FastAPI. Which approach correctly achieves this using pydantic.BaseSettings?

hard

A. Create a Settings class inheriting BaseSettings with class Config: env_file = '.env' and place a .env file in the project root; environment variables override .env values automatically

B. Manually read .env file with open() and parse it, then pass values to Settings constructor

C. Use BaseModel instead of BaseSettings and load .env with dotenv package separately

D. Set environment variables only; .env files are not supported by BaseSettings

Solution

1. Step 1: Understand BaseSettings .env support

   BaseSettings loads .env files when env_file='.env' is set in the inner Config class.

2. Step 2: Know environment variable precedence

   Environment variables override .env file values automatically when both exist.

3. Final Answer:

   Create a Settings class inheriting BaseSettings with class Config: env_file = '.env' and place a .env file in the project root; environment variables override .env values automatically -> Option A

4. Quick Check:

   BaseSettings loads .env via Config env_file and env vars override [OK]

Hint: BaseSettings loads .env via Config(env_file='.env'); env vars override .env values [OK]

Common Mistakes:

• Manually parsing .env instead of using BaseSettings Config
• Using BaseModel which lacks .env support
• Thinking .env files are unsupported by BaseSettings