FastAPI

Create and activate a Python virtual environment on Windows, then install FastAPI and Uvicorn within it.

Write Python functions that accept parameters and return values for simple healthcare-data operations.

Apply Python type hints for strings, numbers, booleans, lists, dictionaries, and optional values.

Transform fictional healthcare records stored in Python lists and dictionaries.

Use conditionals to reject invalid values and raise an appropriate Python exception.

Organize Python code into separate files and import functions between them.

Read a Python traceback to locate and correct a basic coding error.

Identify the method, path, headers, body, and status code in an HTTP request-response exchange.

Represent patients, clinicians, appointments, and medical records as REST resources with clear URL paths.

Select suitable HTTP methods and success status codes for CRUD operations.

Create a FastAPI application and run it locally with Uvicorn's development server.

Implement a GET endpoint that returns a JSON health-check response.

Use FastAPI's interactive API documentation to send a request and inspect its response.

Declare and validate typed path parameters in a FastAPI endpoint.

Declare optional query parameters with defaults and numeric or length limits.

Define a Pydantic request model for structured JSON input.

Apply Pydantic field constraints to validate fictional patient data.

Represent controlled healthcare values with Python enumerations.

Define distinct request and response schemas so clients see only intended fields.

Interpret and correct a FastAPI validation response for malformed input.

Create an in-memory patient repository that assigns a unique identifier to each fictional patient.

Implement a GET endpoint that returns a typed list of patients.

Implement a GET endpoint that returns one patient or a 404 error when the identifier is unknown.

Implement a POST endpoint that validates and creates a patient with a 201 status code.

Implement a PUT endpoint that fully replaces an existing patient's editable data.

Implement a PATCH endpoint that updates only supplied patient fields using Pydantic's unset-field handling.

Implement a DELETE endpoint that removes a patient and returns an appropriate empty response.

Add query-based filtering and pagination to the patient collection endpoint.

Define request and response schemas for a fictional clinician resource.

Implement a POST endpoint that creates a clinician without exposing internal fields.

Implement endpoints that list clinicians and retrieve one clinician by identifier.

Implement an endpoint that updates an existing clinician's editable fields.

Implement an endpoint that deletes a clinician while returning 404 for an unknown identifier.

Define an appointment schema that links patient and clinician identifiers with a scheduled time and status.

Create an appointment only when its referenced patient and clinician both exist.

List appointments with optional filters for patient, clinician, or status.

Update an appointment's scheduled time while rejecting times that violate a stated scheduling rule.

Enforce allowed appointment-status transitions such as scheduled to completed or cancelled.

Define medical-record request and response schemas linked to a fictional patient.

Create a medical record only when its referenced patient exists.

Retrieve medical records for a specified patient with a typed collection response.

Update an existing medical record while preserving its identifier and patient relationship.

Delete a medical record and handle an unknown record identifier consistently.

Use a response model to omit an internal or sensitive field from medical-record responses.

Move each healthcare resource into its own FastAPI APIRouter without changing endpoint behavior.

Provide in-memory repositories to route handlers through FastAPI dependencies.

Return a consistent error structure for not-found and invalid-operation failures.

Assemble the resource routers into one application with clear URL prefixes and tags.

Execute an end-to-end workflow using fictional data through FastAPI's interactive documentation.

Manually verify success, validation, not-found, and invalid-state responses against an endpoint checklist.

Explain why the in-memory project is not suitable for real health data and identify database, authentication, authorization, audit logging, testing, privacy, and deployment as production next steps.