Api reference

components.clinic.public.business_logic

gdpr_compliance

CLINIC_COUNTRY_APP_NAMES module-attribute

CLINIC_COUNTRY_APP_NAMES = [ALAN_FR]

CLINIC_RETENTION_PERIOD_IN_YEARS module-attribute

CLINIC_RETENTION_PERIOD_IN_YEARS = 2

HEALTH_SERVICES_DELETION_CONTRACT module-attribute

HEALTH_SERVICES_DELETION_CONTRACT = DeletionContract(
    producer=health_services,
    owns=frozenset(
        {
            medical_conversation_part,
            therapist_booking_session,
        }
    ),
    reads_as_discriminator=frozenset(),
)

delete_member_data

delete_member_data(global_profile_id)

Delete all clinic data related to a specific member.

Source code in components/clinic/public/business_logic/gdpr_compliance.py

def delete_member_data(global_profile_id: UUID) -> None:
    """Delete all clinic data related to a specific member."""
    from components.clinic.internal.business_logic.clinic_user import (
        delete_all_clinic_data_for_user,
    )

    is_deletion_enabled = bool_feature_flag(
        feature_flag_key="clinic-gdpr-member-data-deletion-killswitch",
        default_value=False,
    )

    current_logger.info(
        "Starting clinic member data deletion",
        global_profile_id=global_profile_id,
        is_deletion_enabled=is_deletion_enabled,
    )

    for app_name in CLINIC_COUNTRY_APP_NAMES:
        feature_user_to_delete = _get_app_feature_user_from_profile_id(
            global_profile_id, app_name
        )

        if not feature_user_to_delete:
            current_logger.info(
                "No feature user found, skipping",
                global_profile_id=global_profile_id,
                app_name=app_name.value,
            )
            continue

        try:
            clinic_user = get_existing_clinic_user_for_feature_user(
                app_user=feature_user_to_delete
            )
        except BaseErrorCode:
            current_logger.info(
                "No clinic user found, skipping",
                global_profile_id=global_profile_id,
                app_id=feature_user_to_delete.app_id,
                app_user_id=feature_user_to_delete.app_user_id,
            )
            continue

        action = "Deleting" if is_deletion_enabled else "Would have deleted"
        current_logger.info(
            f"{action} clinic data for user",
            global_profile_id=global_profile_id,
            clinic_user_id=clinic_user.id,
            is_deletion_enabled=is_deletion_enabled,
        )

        if is_deletion_enabled:
            delete_all_clinic_data_for_user(
                clinic_user_id=clinic_user.id, dry_run=False
            )

    current_logger.info(
        "Completed clinic member data deletion",
        global_profile_id=global_profile_id,
        is_deletion_enabled=is_deletion_enabled,
    )

get_profiles_ready_for_deletion

get_profiles_ready_for_deletion()

Report Clinic's GDPR eligibility per the BucketEligibilityResult contract. We use global profile IDs, because user IDs are not unique between apps (FR/ES/BE)

in the clinic, we define a member as "ready for deletion" in https://github.com/alan-eu/Topics/discussions/31845?sort=old#discussioncomment-15755603 ⧉

The summary of the properties we are interested in: +----------------------------+-----------------------------------------------+-----------------------------------------------+ | Entity Name | Properties Checked | Rationale for Properties Checked | +============================+===============================================+===============================================+ | Medical Conversations | created_at (time of last medical conversation | The user sending a message clearly denotes an | | | part sent by user) | intentional interaction with our health | | | | services. | +----------------------------+-----------------------------------------------+-----------------------------------------------+ | Therapist Booking Sessions | ends_at (time of most recent therapist booking | A session is a clear intention of interaction | | | session where the user was the attending member | with our health services; the time it ends is | | | (clinic_user field)) | when that interaction ended. Sometimes followed| | | | by a medical conversation (covered above). | +----------------------------+-----------------------------------------------+-----------------------------------------------+ | Health Programs | last_updated_at (time of most recent health | This property is updated with any interaction | | | program progress created by the user; denoted by| with a health program. Some interactions may | | | app_id and user_id) | not truly be “program” interactions (e.g., a | | | | rating), but we don’t have a better way to | | | | differentiate between actions, and this catches| | | | them all. | +----------------------------+-----------------------------------------------+-----------------------------------------------+

Source code in components/clinic/public/business_logic/gdpr_compliance.py

@tracer.wrap(service="clinic")
def get_profiles_ready_for_deletion() -> BucketEligibilityResult:
    """
    Report Clinic's GDPR eligibility per the BucketEligibilityResult contract.
    We use global profile IDs, because user IDs are not unique between apps (FR/ES/BE)

    in the clinic, we define a member as "ready for deletion" in https://github.com/alan-eu/Topics/discussions/31845?sort=old#discussioncomment-15755603

    The summary of the properties we are interested in:
    +----------------------------+-----------------------------------------------+-----------------------------------------------+
    | Entity Name                | Properties Checked                              | Rationale for Properties Checked               |
    +============================+===============================================+===============================================+
    | Medical Conversations      | created_at (time of last medical conversation   | The user sending a message clearly denotes an  |
    |                            | part sent by user)                              | intentional interaction with our health        |
    |                            |                                               | services.                                     |
    +----------------------------+-----------------------------------------------+-----------------------------------------------+
    | Therapist Booking Sessions | ends_at (time of most recent therapist booking  | A session is a clear intention of interaction  |
    |                            | session where the user was the attending member | with our health services; the time it ends is  |
    |                            | (clinic_user field))                            | when that interaction ended. Sometimes followed|
    |                            |                                               | by a medical conversation (covered above).     |
    +----------------------------+-----------------------------------------------+-----------------------------------------------+
    | Health Programs            | last_updated_at (time of most recent health     | This property is updated with any interaction  |
    |                            | program progress created by the user; denoted by| with a health program. Some interactions may   |
    |                            | app_id and user_id)                             | not truly be “program” interactions (e.g., a   |
    |                            |                                               | rating), but we don’t have a better way to     |
    |                            |                                               | differentiate between actions, and this catches|
    |                            |                                               | them all.                                      |
    +----------------------------+-----------------------------------------------+-----------------------------------------------+
    """
    from components.clinic.public.dependencies import get_app_dependency

    all_candidate_profile_ids: list[UUID] = []
    profile_to_feature_user: dict[UUID, FeatureUser] = {}
    candidate_inactive_feature_users: list[FeatureUser] = []

    for app_name in CLINIC_COUNTRY_APP_NAMES:
        # collect candidate profiles and their feature user per country
        # each profile has at most 1 feature user per country
        adapter = get_app_dependency(app_name.value)
        current_logger.info("fetching inactive profile IDs", app_name=app_name.value)
        inactive_profile_ids = adapter.get_inactive_profile_ids_since(
            period_in_years=CLINIC_RETENTION_PERIOD_IN_YEARS
        )
        current_logger.info(
            "fetched inactive profile IDs",
            app_name=app_name.value,
            count=len(inactive_profile_ids),
        )
        all_candidate_profile_ids.extend(inactive_profile_ids)

        current_logger.info(
            "resolving profile IDs to feature users",
            app_name=app_name.value,
            count=len(inactive_profile_ids),
        )
        for inactive_profile_id in inactive_profile_ids:
            inactive_feature_user = _get_app_feature_user_from_profile_id(
                inactive_profile_id, app_name
            )

            if inactive_feature_user:
                profile_to_feature_user[inactive_profile_id] = inactive_feature_user
                candidate_inactive_feature_users.append(inactive_feature_user)

        current_logger.info(
            "resolved feature users",
            app_name=app_name.value,
            resolved=len(profile_to_feature_user),
        )

    current_logger.info(
        "total candidate profiles", count=len(all_candidate_profile_ids)
    )

    # batch get existing clinic users (no creation)
    current_logger.info("fetching existing clinic users")
    existing_clinic_users = get_existing_clinic_users_for_feature_users(
        candidate_inactive_feature_users
    )
    current_logger.info(
        "fetched existing clinic users", count=len(existing_clinic_users)
    )

    # resolve profile_id -> clinic_user_id directly
    feature_user_key_to_clinic_user_id = {
        (clinic_user.app_id, clinic_user.app_user_id): clinic_user.id
        for clinic_user in existing_clinic_users
    }
    inactive_profile_to_clinic_user_id = {
        profile_id: feature_user_key_to_clinic_user_id.get(
            (feature_user.app_id, feature_user.app_user_id)
        )
        for profile_id, feature_user in profile_to_feature_user.items()
    }

    candidates_without_clinic_user = len(all_candidate_profile_ids) - len(
        feature_user_key_to_clinic_user_id
    )
    current_logger.info(
        "candidates without clinic user", count=candidates_without_clinic_user
    )

    # batch check for recent interactions
    potentially_inactive_clinic_user_ids = [
        clinic_user_id
        for clinic_user_id in inactive_profile_to_clinic_user_id.values()
        if clinic_user_id is not None
    ]

    current_logger.info(
        "checking recent interactions",
        clinic_user_count=len(potentially_inactive_clinic_user_ids),
    )

    # union of all recent interaction sources
    active_via_conversations = (
        get_subset_of_clinic_user_ids_with_recent_medical_conversation_interactions(
            potentially_inactive_clinic_user_ids
        )
    )
    current_logger.info("active via conversations", count=len(active_via_conversations))

    active_via_sessions = (
        get_subset_of_clinic_user_ids_with_recent_session_interactions(
            potentially_inactive_clinic_user_ids
        )
    )
    current_logger.info("active via sessions", count=len(active_via_sessions))

    active_via_health_programs = (
        get_subset_of_clinic_user_ids_with_recent_health_program_interactions(
            candidate_inactive_feature_users, feature_user_key_to_clinic_user_id
        )
    )
    current_logger.info(
        "active via health programs", count=len(active_via_health_programs)
    )

    active_clinic_user_ids = (
        active_via_conversations | active_via_sessions | active_via_health_programs
    )
    current_logger.info(
        "total active clinic users (union)", count=len(active_clinic_user_ids)
    )

    # disqualify profiles with any recent interaction
    result = [
        profile_id
        for profile_id in all_candidate_profile_ids
        if inactive_profile_to_clinic_user_id.get(profile_id)
        not in active_clinic_user_ids
    ]

    not_ready_yet = [
        profile_id
        for profile_id, clinic_user_id in inactive_profile_to_clinic_user_id.items()
        if clinic_user_id in active_clinic_user_ids
    ]

    current_logger.info("profiles ready for deletion", count=len(result))
    current_logger.info("profiles not ready yet", count=len(not_ready_yet))
    return BucketEligibilityResult(
        ready_for_deletion=result, not_ready_yet=not_ready_yet
    )

get_subset_of_clinic_user_ids_with_recent_health_program_interactions

get_subset_of_clinic_user_ids_with_recent_health_program_interactions(
    feature_users, feature_user_key_to_clinic_user_id
)

Return the subset of clinic user IDs whose corresponding feature users have had health program interactions in the last CLINIC_RETENTION_PERIOD_IN_YEARS years.

Checks the last_updated_at time of the most recent health program progress for each feature user, then maps active feature users back to clinic user IDs.

Parameters:

Name	Type	Description	Default
feature_users	list[FeatureUser]	List of feature users to check	required
feature_user_key_to_clinic_user_id	dict[tuple[str, str], UUID]	Mapping of (app_id, app_user_id) to clinic user ID	required

Source code in components/clinic/public/business_logic/gdpr_compliance.py

@tracer.wrap(service="clinic")
def get_subset_of_clinic_user_ids_with_recent_health_program_interactions(
    feature_users: list[FeatureUser],
    feature_user_key_to_clinic_user_id: dict[tuple[str, str], UUID],
) -> set[UUID]:
    """
    Return the subset of clinic user IDs whose corresponding feature users have had
    health program interactions in the last CLINIC_RETENTION_PERIOD_IN_YEARS years.

    Checks the last_updated_at time of the most recent health program progress for each feature user,
    then maps active feature users back to clinic user IDs.

    Args:
        feature_users: List of feature users to check
        feature_user_key_to_clinic_user_id: Mapping of (app_id, app_user_id) to clinic user ID
    """
    if not feature_users:
        return set()

    cutoff = datetime.now(tz=UTC) - relativedelta(
        years=CLINIC_RETENTION_PERIOD_IN_YEARS
    )
    active_health_programs_feature_users = (
        get_feature_users_with_health_program_interaction_after(feature_users, cutoff)
    )

    active_clinic_user_ids: set[UUID] = set()
    for feature_user in active_health_programs_feature_users:
        clinic_user_id = feature_user_key_to_clinic_user_id.get(
            (feature_user.app_id, feature_user.app_user_id)
        )
        if clinic_user_id is not None:
            active_clinic_user_ids.add(clinic_user_id)

    return active_clinic_user_ids

get_subset_of_clinic_user_ids_with_recent_medical_conversation_interactions

get_subset_of_clinic_user_ids_with_recent_medical_conversation_interactions(
    clinic_user_ids,
)

Return clinic user IDs that had medical conversation interactions within retention period.

Uses batched IN clauses to avoid overwhelming PostgreSQL with large queries.

Parameters:

Name	Type	Description	Default
clinic_user_ids	list[UUID]	List of clinic user IDs to check	required

Source code in components/clinic/public/business_logic/gdpr_compliance.py

@tracer.wrap(service="clinic")
def get_subset_of_clinic_user_ids_with_recent_medical_conversation_interactions(
    clinic_user_ids: list[UUID],
) -> set[UUID]:
    """Return clinic user IDs that had medical conversation interactions within retention period.

    Uses batched IN clauses to avoid overwhelming PostgreSQL with large queries.

    Args:
        clinic_user_ids: List of clinic user IDs to check
    """
    if not clinic_user_ids:
        return set()

    cutoff = datetime.now() - relativedelta(years=CLINIC_RETENTION_PERIOD_IN_YEARS)
    total_batches = math.ceil(len(clinic_user_ids) / _BATCH_SIZE)
    current_logger.info(
        "checking recent conversations in batches",
        total=len(clinic_user_ids),
        total_batches=total_batches,
    )

    result: set[UUID] = set()
    for batch_idx in range(total_batches):
        start = batch_idx * _BATCH_SIZE
        batch = clinic_user_ids[start : start + _BATCH_SIZE]

        rows = (
            current_session.execute(
                select(MedicalConversationPart.clinic_user_author_id)
                .where(
                    MedicalConversationPart.clinic_user_author_id.in_(batch),
                    MedicalConversationPart.created_at > cutoff,
                )
                .distinct()
            )
            .scalars()
            .all()
        )

        batch_result = {uid for uid in rows if uid is not None}
        result.update(batch_result)
        current_logger.info(
            "checked conversations batch",
            batch=batch_idx + 1,
            total_batches=total_batches,
            batch_results=len(batch_result),
        )

    return result

get_subset_of_clinic_user_ids_with_recent_session_interactions

get_subset_of_clinic_user_ids_with_recent_session_interactions(
    clinic_user_ids,
)

Return clinic user IDs that had therapist booking sessions within retention period.

Uses batched IN clauses to avoid overwhelming PostgreSQL with large queries.

Parameters:

Name	Type	Description	Default
clinic_user_ids	list[UUID]	List of clinic user IDs to check	required

Source code in components/clinic/public/business_logic/gdpr_compliance.py

@tracer.wrap(service="clinic")
def get_subset_of_clinic_user_ids_with_recent_session_interactions(
    clinic_user_ids: list[UUID],
) -> set[UUID]:
    """Return clinic user IDs that had therapist booking sessions within retention period.

    Uses batched IN clauses to avoid overwhelming PostgreSQL with large queries.

    Args:
        clinic_user_ids: List of clinic user IDs to check
    """
    if not clinic_user_ids:
        return set()

    cutoff = datetime.now() - relativedelta(years=CLINIC_RETENTION_PERIOD_IN_YEARS)
    total_batches = math.ceil(len(clinic_user_ids) / _BATCH_SIZE)
    current_logger.info(
        "checking recent sessions in batches",
        total=len(clinic_user_ids),
        total_batches=total_batches,
    )

    result: set[UUID] = set()
    for batch_idx in range(total_batches):
        start = batch_idx * _BATCH_SIZE
        batch = clinic_user_ids[start : start + _BATCH_SIZE]

        rows = (
            current_session.execute(
                select(TherapistBookingSession.clinic_user_id)
                .where(
                    TherapistBookingSession.clinic_user_id.isnot(None),
                    TherapistBookingSession.clinic_user_id.in_(batch),
                    TherapistBookingSession.ends_at > cutoff,
                )
                .distinct()
            )
            .scalars()
            .all()
        )

        result.update(rows)
        current_logger.info(
            "checked sessions batch",
            batch=batch_idx + 1,
            total_batches=total_batches,
            batch_results=len(rows),
        )

    return result

get_user_ids_ready_for_deletion

get_user_ids_ready_for_deletion()

Return inactive feature users ready for deletion, bypassing global profiles.

Same retention logic as get_profiles_ready_for_deletion but operates entirely with app user IDs, avoiding the N+1 profile→feature_user resolution.

Returns:

Type	Description
list[FeatureUser]	Feature users whose clinic data is ready for deletion.

Source code in components/clinic/public/business_logic/gdpr_compliance.py

@tracer.wrap(service="clinic")
def get_user_ids_ready_for_deletion() -> list[FeatureUser]:
    """Return inactive feature users ready for deletion, bypassing global profiles.

    Same retention logic as get_profiles_ready_for_deletion but operates entirely
    with app user IDs, avoiding the N+1 profile→feature_user resolution.

    Returns:
        Feature users whose clinic data is ready for deletion.
    """
    from components.clinic.public.dependencies import get_app_dependency

    all_candidates: list[FeatureUser] = []

    for app_name in CLINIC_COUNTRY_APP_NAMES:
        adapter = get_app_dependency(app_name.value)
        current_logger.info("fetching inactive user IDs", app_name=app_name.value)
        inactive_user_ids = adapter.get_inactive_user_ids_since(
            period_in_years=CLINIC_RETENTION_PERIOD_IN_YEARS
        )
        current_logger.info(
            "fetched inactive user IDs",
            app_name=app_name.value,
            count=len(inactive_user_ids),
        )
        all_candidates.extend(
            FeatureUser(app_id=app_name.value, app_user_id=uid)
            for uid in inactive_user_ids
        )

    current_logger.info("total candidate feature users", count=len(all_candidates))

    # batch get existing clinic users (no creation)
    current_logger.info("fetching existing clinic users")
    existing_clinic_users = get_existing_clinic_users_for_feature_users(all_candidates)
    current_logger.info(
        "fetched existing clinic users", count=len(existing_clinic_users)
    )

    feature_user_key_to_clinic_user_id: dict[tuple[str, str], UUID] = {
        (clinic_user.app_id, clinic_user.app_user_id): clinic_user.id
        for clinic_user in existing_clinic_users
    }

    candidates_without_clinic_user = len(all_candidates) - len(
        feature_user_key_to_clinic_user_id
    )
    current_logger.info(
        "candidates without clinic user", count=candidates_without_clinic_user
    )

    potentially_inactive_clinic_user_ids = [
        clinic_user_id
        for clinic_user_id in feature_user_key_to_clinic_user_id.values()
        if clinic_user_id is not None
    ]

    current_logger.info(
        "checking recent interactions",
        clinic_user_count=len(potentially_inactive_clinic_user_ids),
    )

    # union of all recent interaction sources
    active_via_conversations = (
        get_subset_of_clinic_user_ids_with_recent_medical_conversation_interactions(
            potentially_inactive_clinic_user_ids
        )
    )
    current_logger.info("active via conversations", count=len(active_via_conversations))

    active_via_sessions = (
        get_subset_of_clinic_user_ids_with_recent_session_interactions(
            potentially_inactive_clinic_user_ids
        )
    )
    current_logger.info("active via sessions", count=len(active_via_sessions))

    active_via_health_programs = (
        get_subset_of_clinic_user_ids_with_recent_health_program_interactions(
            all_candidates, feature_user_key_to_clinic_user_id
        )
    )
    current_logger.info(
        "active via health programs", count=len(active_via_health_programs)
    )

    active_clinic_user_ids = (
        active_via_conversations | active_via_sessions | active_via_health_programs
    )
    current_logger.info(
        "total active clinic users (union)", count=len(active_clinic_user_ids)
    )

    # disqualify feature users with any recent interaction
    result = [
        feature_user
        for feature_user in all_candidates
        if feature_user_key_to_clinic_user_id.get(
            (feature_user.app_id, feature_user.app_user_id)
        )
        not in active_clinic_user_ids
    ]

    current_logger.info("feature users ready for deletion", count=len(result))
    return result

insi_identity

is_identity_verified_for_user

is_identity_verified_for_user(app_user)

Check if the user's identity is verified.

Parameters:

Name	Type	Description	Default
app_user	FeatureUser	The application user whose identity is to be checked.	required

Returns: bool: True if the user's identity is verified, False otherwise.

Source code in components/clinic/public/business_logic/insi_identity.py

def is_identity_verified_for_user(app_user: FeatureUser) -> bool:
    """
    Check if the user's identity is verified.

    Args:
        app_user (FeatureUser): The application user whose identity is to be checked.
    Returns:
        bool: True if the user's identity is verified, False otherwise.
    """
    clinic_user = get_or_create_clinic_user(app_user=app_user)

    return is_identity_validated(clinic_user_id=clinic_user.id)

medical_conversation

get_first_medical_conversation_for_member

get_first_medical_conversation_for_member(app_user)

Retrieves the first medical conversation for a given member.

This function acts as a proxy to the internal business logic function get_first_medical_conversation_for_member to fetch the first medical conversation associated with the provided app_user.

Parameters:

Name	Type	Description	Default
app_user	FeatureUser	The user for whom the first medical conversation is to be retrieved.	required

Returns:

Type	Description
Optional[MedicalConversation]	Optional[MedicalConversation]: The first medical conversation for the given member, or None if no conversation is found.

Source code in components/clinic/public/business_logic/medical_conversation.py

def get_first_medical_conversation_for_member(
    app_user: FeatureUser,
) -> Optional[MedicalConversation]:
    """
    Retrieves the first medical conversation for a given member.

    This function acts as a proxy to the internal business logic function
    `get_first_medical_conversation_for_member` to fetch the first medical
    conversation associated with the provided `app_user`.

    Args:
        app_user (FeatureUser): The user for whom the first medical conversation
                                is to be retrieved.

    Returns:
        Optional[MedicalConversation]: The first medical conversation for the
                                       given member, or None if no conversation
                                       is found.
    """
    from components.clinic.internal.business_logic.medical_conversation import (
        get_first_medical_conversation_for_member,
    )

    return get_first_medical_conversation_for_member(app_user=app_user)

mark_conversation_as_deleted

mark_conversation_as_deleted(medical_conversation_id)

Source code in components/clinic/public/business_logic/medical_conversation.py

def mark_conversation_as_deleted(medical_conversation_id: UUID) -> None:  # noqa: D103
    from components.clinic.internal.business_logic.medical_chat_bot import (
        get_medical_chat_bot_clinic_user_id,
    )
    from components.clinic.internal.business_logic.medical_conversation import (
        mark_as_deleted,
    )

    mark_as_deleted(
        medical_conversation_id=medical_conversation_id,
        actor_clinic_user_id=get_medical_chat_bot_clinic_user_id(),
    )

therapist_booking_session

get_past_sessions_that_need_invoice_generation_count_for_user

get_past_sessions_that_need_invoice_generation_count_for_user(
    feature_user, session_type
)

Counts the number of past reimbursed therapist booking sessions waiting for invoicing for a specific user and session type. sessions that are waiting for invoicing are those that are not refunded, are confirmed, and have a valid credit. They ended between now and 2 days ago. (default_delay_in_hours is 48)

Arguments: feature_user (FeatureUser): The user for whom upcoming sessions need to be counted. session_type (TherapistBookingSessionType): The type of therapist session to filter by.

Returns: int: The count of done reimbursed therapist booking sessions matching the provided user and session type.

Source code in components/clinic/public/business_logic/therapist_booking_session.py

def get_past_sessions_that_need_invoice_generation_count_for_user(
    feature_user: FeatureUser, session_type: TherapistBookingSessionType
) -> int:
    """
    Counts the number of past reimbursed therapist booking sessions waiting for
    invoicing for a specific user and session type.
    sessions that are waiting for invoicing are those that are not refunded, are
    confirmed, and have a valid credit. They ended between now and 2 days ago. (default_delay_in_hours is 48)

    Arguments:
    feature_user (FeatureUser): The user for whom upcoming sessions need
    to be counted.
    session_type (TherapistBookingSessionType): The type of therapist session
    to filter by.

    Returns:
    int: The count of done reimbursed therapist booking sessions matching the
    provided user and session type.
    """
    clinic_user = get_or_create_clinic_user(app_user=feature_user)

    return int(
        get_past_sessions_that_need_invoices_query(
            clinic_user_id=clinic_user.id,
            session_type=session_type,
            min_date=(datetime.now() - timedelta(hours=DEFAULT_DELAY_IN_HOURS)),
            delay_in_hours=0,
        ).count()
    )

get_upcoming_reimbursed_therapist_booking_session_count_for_user

get_upcoming_reimbursed_therapist_booking_session_count_for_user(
    feature_user, session_type
)

Counts the number of upcoming reimbursed therapist booking sessions for a specific user and session type. Only counts sessions that are not refunded, are confirmed, have a valid credit, and are scheduled for a future date.

Arguments: feature_user (FeatureUser): The user for whom upcoming sessions need to be counted. session_type (TherapistBookingSessionType): The type of therapist session to filter by.

Returns: int: The count of upcoming reimbursed therapist booking sessions matching the provided user and session type.

Source code in components/clinic/public/business_logic/therapist_booking_session.py

def get_upcoming_reimbursed_therapist_booking_session_count_for_user(
    feature_user: FeatureUser, session_type: TherapistBookingSessionType
) -> int:
    """
    Counts the number of upcoming reimbursed therapist booking sessions for a
    specific user and session type. Only counts sessions that are not refunded,
    are confirmed, have a valid credit, and are scheduled for a future date.

    Arguments:
    feature_user (FeatureUser): The user for whom upcoming sessions need
    to be counted.
    session_type (TherapistBookingSessionType): The type of therapist session
    to filter by.

    Returns:
    int: The count of upcoming reimbursed therapist booking sessions matching
    the provided user and session type.
    """
    from components.clinic.internal.booking.models.therapist_booking_session import (
        TherapistBookingSession,
    )

    clinic_user = get_or_create_clinic_user(app_user=feature_user)

    return int(
        current_session.query(TherapistBookingSession)  # noqa: ALN085
        .filter(
            TherapistBookingSession.is_refunded == False,
            TherapistBookingSession.confirmed_at.isnot(None),
            TherapistBookingSession.clinic_user_id == clinic_user.id,
            TherapistBookingSession.session_type == session_type,
            TherapistBookingSession.starts_at > datetime.now(),
            TherapistBookingSession.therapist_booking_user_credit_id.isnot(None),
        )
        .count()
    )

user

app_user_has_upcoming_availability_for_alan_consultations

app_user_has_upcoming_availability_for_alan_consultations(
    member_app_user,
    locale=None,
    availability_threshold_in_hours=24,
    medical_admins_ids=None,
)

Returns true if the given member is able to book an Alan consultation within the following upcoming parameters: - next availability is within the next availability threshold in hours (24 hours by default)

Source code in components/clinic/public/business_logic/user.py

def app_user_has_upcoming_availability_for_alan_consultations(
    member_app_user: FeatureUser,
    locale: Optional[str] = None,
    availability_threshold_in_hours: Optional[int] = 24,
    medical_admins_ids: Optional[
        list[str]
    ] = None,  # if this argument is passed, we filter the medical admins to only choose those with an id in this list
) -> bool:
    """
    Returns true if the given member is able to book an Alan consultation within the following upcoming parameters:
    - next availability is within the next availability threshold in hours (24 hours by default)
    """
    from components.clinic.internal.business_logic.medical_admin import (
        get_medical_admins_for_member,
    )

    # general practitioners that are bookable online are the only ones that do Alan consultations
    available_medical_admins = get_medical_admins_for_member(
        app_user=member_app_user,
        is_bookable_online=True,
        locale=locale,
        medical_specialties=[MedicalAdminSpecialty.GENERAL_PRACTITIONER],
        medical_admins_ids=medical_admins_ids,
        availability_threshold_in_hours=availability_threshold_in_hours,
    )

    # since we applied the availability threshold filter, if there are no available medical admins, it means that the member is not able to book an Alan consultation within the given upcoming availability
    return len(available_medical_admins) > 0

get_clinic_user_for_french_user

get_clinic_user_for_french_user(user_id)

Source code in components/clinic/public/business_logic/user.py

def get_clinic_user_for_french_user(user_id: int) -> ClinicUser | None:  # noqa: D103
    from components.clinic.internal.business_logic.clinic_user import (
        get_clinic_user_for_french_user,
    )

    return get_clinic_user_for_french_user(user_id)

get_medical_admin_for_user

get_medical_admin_for_user(user_id, not_deleted=True)

Source code in components/clinic/public/business_logic/user.py

def get_medical_admin_for_user(  # noqa: D103
    user_id: int, not_deleted: Optional[bool] = True
) -> MedicalAdmin | None:
    from components.clinic.internal.business_logic.medical_admin import (
        get_medical_admin_by_app_user,
    )

    return get_medical_admin_by_app_user(
        medical_admin_app_user=FeatureUser(
            app_user_id=str(user_id),
            app_id=get_current_app_name(),
        ),
        not_deleted=not_deleted,
    )

has_app_user_access_to_orientation

has_app_user_access_to_orientation(app_user)

Source code in components/clinic/public/business_logic/user.py

def has_app_user_access_to_orientation(app_user: FeatureUser) -> bool:  # noqa: D103
    from components.clinic.internal.booking.business_logic.sessions_queries import (
        has_app_user_access_to_orientation,
    )

    return has_app_user_access_to_orientation(app_user=app_user)

update_clinic_consent_for_user

update_clinic_consent_for_user(
    actor_user, has_given_consent, delete_existing_data=True
)

Update the clinic user consent

Parameters:

Name	Type	Description	Default
actor_user	FeatureUser	The actor feature user	required
has_given_consent	bool	The user has given his consent	required
delete_existing_data	Optional[bool]	Has to delete existing data status	True

Source code in components/clinic/public/business_logic/user.py

def update_clinic_consent_for_user(
    actor_user: FeatureUser,
    has_given_consent: bool,
    delete_existing_data: Optional[bool] = True,
) -> None:
    """
    Update the clinic user consent

    Args:
        actor_user: The actor feature user
        has_given_consent: The user has given his consent
        delete_existing_data: Has to delete existing data status
    """
    from components.clinic.internal.business_logic.clinic_user import (
        update_clinic_consent,
    )

    update_clinic_consent(
        actor_app_user=actor_user,
        has_given_consent=has_given_consent,
        delete_existing_data=delete_existing_data,
    )

validate_child_dependent

validate_child_dependent_and_get_feature_user

validate_child_dependent_and_get_feature_user(
    parent_user, child_app_user_id
)

Validate that a child is a dependent of the current user and return a FeatureUser for the child.

Parameters:

Name	Type	Description	Default
parent_user	FeatureUser	The current user (parent)	required
child_app_user_id	str	The ID of the child to validate	required

Source code in components/clinic/public/business_logic/validate_child_dependent.py

def validate_child_dependent_and_get_feature_user(
    parent_user: FeatureUser, child_app_user_id: str
) -> FeatureUser:
    """
    Validate that a child is a dependent of the current user and return a FeatureUser for the child.

    Args:
        parent_user: The current user (parent)
        child_app_user_id: The ID of the child to validate

    Raises:
        BaseErrorCode.forbidden if user has no dependents or child is not a dependent of current user
    """
    # Get the app user data of the current user
    user_data = get_app_dependency(parent_user.app_id).get_app_user_data(
        app_user_id=parent_user.app_user_id
    )

    if not user_data.dependents:
        raise BaseErrorCode.forbidden(message="User has no dependents")

    # Get the list of dependent app_user_ids
    dependent_ids = [
        dependent.app_user_id
        for dependent in user_data.dependents
        if dependent.app_user_id
    ]

    if child_app_user_id not in dependent_ids:
        raise BaseErrorCode.forbidden(
            message="Child is not a dependent of the current user"
        )

    # Create and return feature user for the child
    return FeatureUser(
        app_user_id=child_app_user_id,
        app_id=parent_user.app_id,
    )

components.clinic.public.commands

app_group

clinic_commands module-attribute

clinic_commands = AppGroup('clinic')

register_clinic_commands

register_clinic_commands()

Source code in components/clinic/public/commands/app_group.py

def register_clinic_commands() -> None:  # noqa: D103
    from components.clinic.public.commands import (  # noqa: F401
        billing_assurance_maladie,
        clinic_invoices,
        end_to_end_test,
        gdpr_compliance,
        medical_admins,
        medical_conversation,
        setup,
        unread_message_reminders,
        user,
    )

billing_assurance_maladie

setup_test_data_for_billing_assurance_maladie

setup_test_data_for_billing_assurance_maladie(
    medical_admin_id,
    operator_email,
    password,
    sessions_per_user,
    dry_run,
)

Seed members + Intellio patients + past consultations to test Assurance Maladie billing.

Local (dev) and staging only (live Intellio Editeurs sandbox). Idempotent. See the business-logic module for the full flow.

Source code in components/clinic/public/commands/billing_assurance_maladie.py

@clinic_commands.command()
@click.option(
    "--medical-admin-id",
    type=click.UUID,
    prompt="Medical admin id to assign teleconsultations to",
    help="Id of the medical admin the consultations are booked with.",
)
@click.option(
    "--operator-email",
    type=str,
    default=lambda: aws_user_email() or None,
    prompt="Your Alan email (members emails will be created as <local>+<firstName>@<domain>)",
    help="Email the test members are plus-tagged off. Defaults to your IAM identity.",
)
@click.option(
    "--password", type=str, default="azerty", help="Password for every created member."
)
@click.option(
    "--sessions-per-user",
    type=int,
    default=3,
    show_default=True,
    help="Number of past consultation sessions to create per member.",
)
@command_with_dry_run
def setup_test_data_for_billing_assurance_maladie(
    medical_admin_id: uuid.UUID,
    operator_email: str,
    password: str,
    sessions_per_user: int,
    dry_run: bool,
) -> None:
    """Seed members + Intellio patients + past consultations to test Assurance Maladie billing.

    Local (dev) and staging only (live Intellio Editeurs sandbox). Idempotent.
    See the business-logic module for the full flow.
    """
    from components.clinic.internal.business_logic.billing_assurance_maladie.seed_data_for_intellio_editeurs import (
        SHEET_NAME,
        get_billable_medical_admin,
        parse_test_patients_from_workbook,
        seed_billing_assurance_maladie_test_data,
    )

    if is_production_mode():
        click.echo("This command is not available in prod!")
        return

    try:
        patients = parse_test_patients_from_workbook()
        click.echo(f"Parsed {len(patients)} distinct patient(s) from {SHEET_NAME}:")
        for patient in patients:
            click.echo(
                f"  - {patient.last_name} {patient.first_name} "
                f"({patient.gender.value}) NIR={patient.nir}/{patient.nir_cle} "
                f"né(e) le {patient.birth_date.isoformat()}"
            )

        # Validate the medical admin upfront (even on a dry run).
        medical_admin = get_billable_medical_admin(medical_admin_id)

        if dry_run:
            click.echo("\nDry run — no members, Intellio patients or sessions created.")
            return

        members = seed_billing_assurance_maladie_test_data(
            medical_admin_id=medical_admin_id,
            operator_email=operator_email,
            password=password,
            sessions_per_user=sessions_per_user,
        )
    except ValueError as error:
        raise click.ClickException(str(error)) from error

    for member in members:
        click.echo(
            f"✓ {member.last_name} {member.first_name}: member {member.email} / "
            f"{password}, clinic_user {member.clinic_user_id}, intellio patient "
            f"{member.intellio_editeurs_patient_id}"
        )
    total_sessions = sum(member.sessions_created for member in members)
    click.echo(
        f"\nDone. {len(members)} member(s) ensured, {total_sessions} new consultation "
        f"session(s) assigned to {medical_admin.full_name} ({medical_admin_id})."
    )

booking

app_group

booking_commands module-attribute

booking_commands = AppGroup('booking')

register_booking_commands

register_booking_commands()

Source code in components/clinic/public/commands/booking/app_group.py

def register_booking_commands() -> None:  # noqa: D103
    from components.clinic.public.commands.booking import (  # noqa: F401
        notifications,
        sessions,
        therapists,
    )

notifications

notify_all_scheduled_messages

notify_all_scheduled_messages()

Source code in components/clinic/public/commands/booking/notifications.py

@booking_commands.command()
@command_with_dry_run
def notify_all_scheduled_messages() -> None:  # noqa: D103
    from components.clinic.internal.booking.business_logic.notifications import (
        notify_all_scheduled_messages,
    )

    notify_all_scheduled_messages()

sessions

cancel_all_future_sessions_for_medical_admin_as_medical_admin

cancel_all_future_sessions_for_medical_admin_as_medical_admin(
    dry_run, medical_admin_id
)

Cancels all future sessions for a given medical admin as if the same medical admin is cancelling them themselves. This is useful when a medical admin is departing Alan, and we want all the members with booked sessions to receive the appropriate notifications for the cancellation.

Source code in components/clinic/public/commands/booking/sessions.py

@booking_commands.command()
@click.option(
    "--medical-admin-id",
    type=str,
    required=True,
)
@command_with_dry_run
def cancel_all_future_sessions_for_medical_admin_as_medical_admin(
    dry_run: bool,
    medical_admin_id: str,
) -> None:
    """Cancels all future sessions for a given medical admin as if the same medical admin is cancelling them themselves.
    This is useful when a medical admin is departing Alan, and we want all the members with booked sessions to receive the appropriate notifications for the cancellation.
    """
    from components.clinic.internal.booking.business_logic.sessions_actions import (
        cancel_session_for_expert,
    )
    from components.clinic.internal.booking.business_logic.sessions_queries import (
        get_therapist_upcoming_sessions,
    )
    from components.clinic.internal.models.medical_admin import MedicalAdmin
    from shared.helpers.get_or_else import get_or_raise_missing_resource
    from shared.helpers.logging.logger import current_logger

    # get the feature user for the medical admin
    medical_admin = get_or_raise_missing_resource(MedicalAdmin, medical_admin_id)
    medical_admin_feature_user = medical_admin.clinic_user.feature_user

    # get all the sessions for the medical admin
    sessions = get_therapist_upcoming_sessions(
        actor_app_user=medical_admin_feature_user,
    )

    current_logger.info(
        f"Found {len(sessions)} upcoming sessions for medical admin {medical_admin_id}"
    )

    # cancel each session as the medical admin
    for num_cancelled, session in enumerate(sessions, 1):
        if dry_run:
            current_logger.info(f"DRY RUN: Would have cancelled session {session.id}")
        else:
            current_logger.info(f"Cancelling session {session.id}")

        cancel_session_for_expert(
            session_id=session.id,
            actor_app_user=medical_admin_feature_user,
            dry_run=dry_run,
        )
        if num_cancelled % 5 == 0:
            current_logger.info(f"Cancelled {num_cancelled}/{len(sessions)} sessions")

    current_logger.info(f"Completed. Cancelled {len(sessions)} sessions")

delete_test_sessions

delete_test_sessions()

Source code in components/clinic/public/commands/booking/sessions.py

@booking_commands.command()
@do_not_run_in_prod
def delete_test_sessions() -> None:  # noqa: D103
    from components.clinic.internal.booking.business_logic.end_to_end_test import (
        delete_test_sessions,
    )

    delete_test_sessions()

expire_booking_invites

expire_booking_invites(dry_run)

Source code in components/clinic/public/commands/booking/sessions.py

@booking_commands.command()
@command_with_dry_run
def expire_booking_invites(dry_run: bool) -> None:  # noqa: D103
    from components.clinic.internal.booking.business_logic.sessions_actions import (
        cancel_all_expired_invites,
    )

    cancel_all_expired_invites(dry_run=dry_run)

generate_past_sessions_invoice

generate_past_sessions_invoice(dry_run=False)

Source code in components/clinic/public/commands/booking/sessions.py

@booking_commands.command()
@command_with_dry_run
def generate_past_sessions_invoice(dry_run: bool = False) -> None:  # noqa: D103
    from components.clinic.internal.booking.business_logic.sessions_invoicing import (
        generate_past_sessions_invoice,
    )

    generate_past_sessions_invoice(dry_run=dry_run)

generate_sessions_invoices

generate_sessions_invoices(dry_run)

Source code in components/clinic/public/commands/booking/sessions.py

@booking_commands.command()
@command_with_dry_run
def generate_sessions_invoices(dry_run: bool) -> None:  # noqa: D103
    from components.clinic.internal.booking.business_logic.sessions_invoicing import (
        generate_sessions_invoices,
    )

    generate_sessions_invoices(dry_run=dry_run)

push_metadata_to_doctor_ai_for_recent_ended_sessions_booked_from_mo

push_metadata_to_doctor_ai_for_recent_ended_sessions_booked_from_mo(
    dry_run,
)

Push the metadata of recent ended sessions (<48 hours ago) booked from Mo to Doctor AI.

Source code in components/clinic/public/commands/booking/sessions.py

@booking_commands.command()
@command_with_dry_run
def push_metadata_to_doctor_ai_for_recent_ended_sessions_booked_from_mo(
    dry_run: bool,
) -> None:
    """Push the metadata of recent ended sessions (<48 hours ago) booked from Mo to Doctor AI."""
    from components.clinic.internal.booking.business_logic.events_subscribers import (
        track_lifecycle_event_for_session_from_mo_redirection,
    )
    from components.clinic.internal.booking.business_logic.sessions_queries import (
        get_recent_ended_sessions_booked_from_mo,
    )
    from components.clinic.internal.booking.entities.events import (
        SessionRecommendedByMoWasUpdated,
    )
    from shared.helpers.logging.logger import current_logger

    sessions = get_recent_ended_sessions_booked_from_mo()

    for session in sessions:
        if dry_run:
            current_logger.info(
                f"DRY RUN: Would have pushed metadata to Doctor AI for session {session.id} with prescription types {session.prescription_types}"
            )
            continue

        # We can afford running the event synchronously here as we are not a user facing process
        # and operate on a small batch (max 10^2)
        track_lifecycle_event_for_session_from_mo_redirection(
            event=SessionRecommendedByMoWasUpdated(
                session_id=session.id,
                metadata={
                    "status": "did_happen",
                    "prescription_types": session.prescription_types,
                },
            )
        )

refund_payment_not_linked_to_session

refund_payment_not_linked_to_session(dry_run)

Source code in components/clinic/public/commands/booking/sessions.py

@booking_commands.command()
@command_with_dry_run
def refund_payment_not_linked_to_session(dry_run: bool) -> None:  # noqa: D103
    from components.clinic.internal.booking.business_logic.credits import (
        refund_payment_not_linked_to_session,
    )

    refund_payment_not_linked_to_session(dry_run=dry_run)

therapists

update_cached_next_availability

update_cached_next_availability(dry_run)

Source code in components/clinic/public/commands/booking/therapists.py

@booking_commands.command()
@command_with_dry_run
def update_cached_next_availability(dry_run: bool) -> None:  # noqa: D103
    from components.clinic.internal.booking.business_logic.therapists import (
        update_cached_next_availability_of_all_therapists,
    )

    update_cached_next_availability_of_all_therapists(commit=not dry_run)

clinic_invoices

generate_fake_clinic_invoices

generate_fake_clinic_invoices(dry_run)

Source code in components/clinic/public/commands/clinic_invoices.py

@clinic_commands.command()
@command_with_dry_run
@do_not_run_in_prod
def generate_fake_clinic_invoices(dry_run: bool) -> None:  # noqa: D103
    from components.clinic.internal.business_logic.clinic_invoice import (
        generate_fake_clinic_invoices,
    )

    generate_fake_clinic_invoices(dry_run=dry_run)

sync_clinic_monthly_invoice_lines_from_turing

sync_clinic_monthly_invoice_lines_from_turing(
    dry_run, date, previous_month, mapped_ids
)

Source code in components/clinic/public/commands/clinic_invoices.py

@clinic_commands.command()
@command_with_dry_run
@click.option(
    "--date",
    type=click.DateTime(formats=["%Y-%m-%d"]),
    required=False,
    help="Date in YYYY-MM-DD format (e.g., 2021-09-01)",
)
@click.option(
    "--previous-month",
    is_flag=True,
    default=False,
    help="Run invoice generation for the previous month",
)
@click.option(
    "--mapped_ids",
    type=str,
    required=False,
    help="Optional mapping of origin IDs to target IDs in the format 'originid1:targetid1,originid2:targetid2'. If provided, only the specified origin IDs will be queried from Turing, and the corresponding target IDs will be used when inserting into the backend database.",
)
def sync_clinic_monthly_invoice_lines_from_turing(  # noqa: D103
    dry_run: bool,
    date: Optional[datetime.date],
    previous_month: bool,
    mapped_ids: Optional[str],
) -> None:
    from components.clinic.internal.business_logic.clinic_invoice import (
        sync_clinic_monthly_invoice_lines_from_turing,
    )

    if date and previous_month:
        raise click.BadParameter(
            "You can't specify both --date and --previous-month options"
        )

    if previous_month:
        date = (
            datetime.date.today().replace(day=1) - datetime.timedelta(days=1)
        ).replace(day=1)
        click.echo(f"Invoicing date: {date}")

    result = sync_clinic_monthly_invoice_lines_from_turing(
        dry_run=dry_run,
        date=date,
        mapped_ids=mapped_ids,
    )

    if not dry_run:
        current_app.slack_web_client.chat_postMessage(  # type: ignore[attr-defined]
            channel=(
                SlackChannel.alan_clinic_ops_channel
                if is_production_mode()
                else SlackChannel.test
            ),
            username="Clinic Bot",
            icon_emoji=":moneybag:",
            text=(
                f"👋 I just finished generating {result.created_invoices_count} invoices (for the {result.invoicing_date} date)."
                "\nHead over <https://alan.com/marmot-v2/alan-clinic/invoices|the billing page> in Marmot and send the invoices for validation 🍔"
                + (
                    f"\nnote: {result.removed_invoices_count} draft invoice(s) were first removed when generating today's invoices."
                    if result.removed_invoices_count
                    else ""
                )
            ),
        )

end_to_end_test

delete_test_conversations

delete_test_conversations()

Source code in components/clinic/public/commands/end_to_end_test.py

@clinic_commands.command()
@do_not_run_in_prod
def delete_test_conversations() -> None:  # noqa: D103
    from components.clinic.internal.business_logic.end_to_end_test import (
        delete_test_conversations,
    )

    delete_test_conversations()

keep_last_part_from_test_conversations

keep_last_part_from_test_conversations()

Source code in components/clinic/public/commands/end_to_end_test.py

@clinic_commands.command()
@do_not_run_in_prod
def keep_last_part_from_test_conversations() -> None:  # noqa: D103
    from components.clinic.internal.business_logic.end_to_end_test import (
        keep_last_part_from_test_conversations,
    )

    keep_last_part_from_test_conversations()

gdpr_compliance

get_user_ids_ready_for_deletion

get_user_ids_ready_for_deletion()

Return feature users whose clinic data is ready for GDPR deletion.

Source code in components/clinic/public/commands/gdpr_compliance.py

@clinic_commands.command()
def get_user_ids_ready_for_deletion() -> None:
    """Return feature users whose clinic data is ready for GDPR deletion."""
    from components.clinic.public.business_logic.gdpr_compliance import (
        get_user_ids_ready_for_deletion as _get_user_ids_ready_for_deletion,
    )

    feature_users = _get_user_ids_ready_for_deletion()

    current_logger.info(
        "user IDs ready for deletion",
        count=len(feature_users),
    )

medical_admins

backfill_medical_admin_synced_ans_data

backfill_medical_admin_synced_ans_data(dry_run)

This temporary command creates ANS data for medical admins that have a medical_identifier but don't have associated ANS data yet.

TODO: @sarah.louahem Remove this command once run in prod - we now create ANS data automatically.

Source code in components/clinic/public/commands/medical_admins.py

@clinic_commands.command()
@command_with_dry_run
def backfill_medical_admin_synced_ans_data(dry_run: bool) -> None:
    """
    This temporary command creates ANS data for medical admins that have
    a medical_identifier but don't have associated ANS data yet.

    TODO: @sarah.louahem Remove this command once run in prod - we now create ANS data automatically.
    """
    from components.clinic.internal.business_logic.medical_admin_ans import (
        backfill_medical_admin_synced_ans_data as backfill_ans_data,
    )

    click.echo(f"Starting backfill of medical admin ANS data with dry_run={dry_run}")

    try:
        backfill_ans_data(dry_run)
        click.echo(f"Backfill completed successfully with dry_run={dry_run}")
    except Exception as error:
        click.echo(
            f"Error during backfill: {error}",
            err=True,
        )
        raise

create_medical_admins

create_medical_admins(password, alaner_email, dry_run)

Truncate and recreate every MedicalAdmin from the local dataset.

Source code in components/clinic/public/commands/medical_admins.py

@clinic_commands.command()
@click.option(
    "--password", help="Password for all the accounts", type=str, default="azerty"
)
@click.option(
    "--alaner-email",
    type=str,
    default=lambda: aws_user_email(),
    show_default=True,
    help="Base alaner email used to plus-tag each admin (<local>+<lastname>@<domain>). Defaults to your AWS IAM identity.",
)
@command_with_dry_run
def create_medical_admins(password: str, alaner_email: str, dry_run: bool) -> None:
    """Truncate and recreate every `MedicalAdmin` from the local dataset."""
    _create_medical_admins(
        password=password, alaner_email=alaner_email, dry_run=dry_run
    )

create_medical_chat_bot

create_medical_chat_bot()

Source code in components/clinic/public/commands/medical_admins.py

@clinic_commands.command()
def create_medical_chat_bot() -> None:  # noqa: D103
    from components.clinic.internal.business_logic.medical_chat_bot import (
        create_medical_chat_bot_clinic_user,
        medical_chat_bot_clinic_user_exists,
    )

    if not is_development_mode():
        click.echo("This command is only available in development mode!")
        return

    if medical_chat_bot_clinic_user_exists():
        click.echo("The Medical Chat Bot already exists.")
    else:
        create_medical_chat_bot_clinic_user()

set_offline_inactive_medical_admin

set_offline_inactive_medical_admin(minutes, dry_run)

Source code in components/clinic/public/commands/medical_admins.py

@clinic_commands.command()
@click.option(
    "--minutes",
    type=int,
    default=30,
    help="Number of minutes before medical admin is inactive",
)
@command_with_dry_run
def set_offline_inactive_medical_admin(minutes: int, dry_run: bool) -> None:  # noqa: D103
    from components.clinic.internal.business_logic.medical_admin import (
        set_offline_inactive_medical_admins,
    )

    set_offline_inactive_medical_admins(
        minutes=minutes,
        dry_run=dry_run,
    )

sync_medical_admin_ans_data

sync_medical_admin_ans_data(dry_run)

Sync medical admin ANS data with the ANS FHIR API.

This command checks all stored medical admin ANS data and updates records that have older versions than what's available in the ANS FHIR API.

Source code in components/clinic/public/commands/medical_admins.py

@clinic_commands.command()
@command_with_dry_run
def sync_medical_admin_ans_data(dry_run: bool) -> None:
    """
    Sync medical admin ANS data with the ANS FHIR API.

    This command checks all stored medical admin ANS data and updates records
    that have older versions than what's available in the ANS FHIR API.
    """
    from components.clinic.internal.business_logic.medical_admin_ans import (
        sync_outdated_medical_admin_ans_data,
    )

    click.echo(f"Starting sync of medical admin ANS data with dry_run={dry_run}")

    try:
        sync_outdated_medical_admin_ans_data(dry_run)
        click.echo(f"Sync completed successfully with dry_run={dry_run}")
    except Exception as error:
        click.echo(
            f"Error during sync: {error}",
            err=True,
        )
        raise

medical_admins_dataset

MedicalAdminData dataclass

MedicalAdminData(
    first_name,
    last_name,
    onboarding_status,
    accessible_conversation_specialties,
    apps_displayed_in,
    has_access_to_app_ids,
    access_types,
    specialty,
    country,
    languages,
    description=None,
    experiences=None,
    answers_to_proactive_conversation_topics=None,
    prod_id=None,
    dato_id=None,
    first_message_body=None,
    avatar=None,
    clinic_role=None,
)

access_types instance-attribute

access_types

accessible_conversation_specialties instance-attribute

accessible_conversation_specialties

answers_to_proactive_conversation_topics class-attribute instance-attribute

answers_to_proactive_conversation_topics = None

apps_displayed_in instance-attribute

apps_displayed_in

avatar class-attribute instance-attribute

avatar = None

clinic_role class-attribute instance-attribute

clinic_role = None

country instance-attribute

country

dato_id class-attribute instance-attribute

dato_id = None

description class-attribute instance-attribute

description = None

experiences class-attribute instance-attribute

experiences = None

first_message_body class-attribute instance-attribute

first_message_body = None

first_name instance-attribute

first_name

has_access_to_app_ids instance-attribute

has_access_to_app_ids

languages instance-attribute

languages

last_name instance-attribute

last_name

onboarding_status instance-attribute

onboarding_status

prod_id class-attribute instance-attribute

prod_id = None

specialty instance-attribute

specialty

MedicalAdminExperienceData dataclass

MedicalAdminExperienceData(title, subtitle, index)

index instance-attribute

index

subtitle instance-attribute

subtitle

title instance-attribute

title

RAW_MEDICAL_ADMINS module-attribute

RAW_MEDICAL_ADMINS = [
    MedicalAdminData(
        first_name="Augustin",
        last_name="Beaucote",
        specialty=GENERAL_PRACTITIONER,
        avatar="http://eu.alan.uploads.s3.eu-central-1.amazonaws.com/manual_upload/9d775ac221a84812a3cc18bae63b7766_doctor_beaucote_headshot.jpg",
        description="Je suis médecin généraliste et immunologue et j’ai rejoint Alan début 2020 pour développer les services de santé.\nJ’ai fait mes études en région parisienne à la faculté du Kremlin Bicêtre avant de rejoindre la région de Montpellier en 2015, où j’ai été interne pendant 3 ans.\nJ’ai choisi de me spécialiser en immunologie et j’ai fait des remplacements en cabinet de médecine générale et aux urgences adultes et pédiatriques.",
        experiences=[
            MedicalAdminExperienceData(
                title="Immunothérapies ciblées des maladies",
                subtitle="Faculté de médecine de Montpellier",
                index=3,
            ),
            MedicalAdminExperienceData(
                title="Master 2, Génome et différenciation cellulaire - Hématopoïèse",
                subtitle="Université Paris Diderot et IGMM",
                index=2,
            ),
            MedicalAdminExperienceData(
                title="DESC 2 d'immunologie clinique",
                subtitle="Université de Montpellier",
                index=1,
            ),
            MedicalAdminExperienceData(
                title="Doctorat en Médecine Générale",
                subtitle="Faculté de médecine de Montpellier",
                index=0,
            ),
        ],
        apps_displayed_in=[alan_insurance],
        accessible_conversation_specialties=[
            GENERAL_MEDICINE,
            PEDIATRICS,
            CHILDCARE,
            DIETETICS,
            DERMATOLOGY,
            PHYSIOTHERAPY,
            GYNECOLOGY,
        ],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        answers_to_proactive_conversation_topics=[
            SLEEP,
            STRESS,
        ],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
    ),
    MedicalAdminData(
        first_name="Clara",
        last_name="Poncelet",
        specialty=MIDWIFE,
        first_message_body="Je suis Clara, je suis sage-femme, j’exerce en Suisse dans une structure hospitalière et en France comme sage-femme libérale. Je suis aussi maman d’une petite fille depuis fin 2020 !",
        avatar="http://eu.alan.uploads.s3.eu-central-1.amazonaws.com/manual_upload/3fec273f3a484072b50029a7ee7a0440_clara_poncelet.jpg",
        description="Je suis sage-femme depuis 2015 et heureuse nouvelle arrivée chez Alan.\nCes cinq dernières années sont marquées par mes voyages régionaux car j’ai choisi d’exercer dans différents grands centres hospitaliers afin d’enrichir ma formation.\nDepuis 2019 je fais des remplacements en libéral pour un accompagnement semi-global et j’exerce en Suisse dans une structure hospitalière. Je me forme dans les domaines ouverts aux sages-femmes dès que j’en ai l’occasion pour adapter mes pratiques.\nJe suis maman d’une petite fille depuis fin 2020.",
        experiences=[
            MedicalAdminExperienceData(
                title="Diplôme de sage-femme en 2015",
                subtitle="Université de Bourgogne à Dijon",
                index=0,
            )
        ],
        accessible_conversation_specialties=[GYNECOLOGY],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
    ),
    MedicalAdminData(
        first_name="Barbara",
        last_name="Dezileaux",
        specialty=GENERAL_PRACTITIONER,
        avatar="http://eu.alan.uploads.s3.eu-central-1.amazonaws.com/manual_upload/8b28ef4ffbea476c93565ad2d3cd4eb7_doctor_dezileaux_headshot.jpg",
        description="Médecin généraliste, j’ai choisi de rejoindre les équipes d’Alan car j’apprécie leur démarche d’aide et de conseil envers leurs utilisateurs.\nJe suis diplômée depuis 2015, après avoir réalisé mes études à Bordeaux puis mon internat à Lille.\nJ’exerce depuis en cabinet libéral et en clinique dans différentes régions de France.\nJ’ai à cœur de me former en continu, en particulier sur les sujets de la maternité et de la périnatalité qui me passionnent.",
        experiences=[
            MedicalAdminExperienceData(
                title="Doctorat en Médecine Générale",
                subtitle="Faculté de médecine de Lille",
                index=0,
            )
        ],
        accessible_conversation_specialties=[
            GENERAL_MEDICINE,
            PEDIATRICS,
            CHILDCARE,
            DIETETICS,
            DERMATOLOGY,
            PHYSIOTHERAPY,
            GYNECOLOGY,
        ],
        apps_displayed_in=[alan_insurance],
        access_types=[CHAT],
        has_access_to_app_ids=[ALAN_FR],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
    ),
    MedicalAdminData(
        first_name="Marion",
        last_name="Cosson",
        specialty=GENERAL_PRACTITIONER,
        clinic_role=CLINIC_ADMIN,
        apps_displayed_in=[],
        has_access_to_app_ids=[ALAN_FR],
        accessible_conversation_specialties=[
            GENERAL_MEDICINE,
            PEDIATRICS,
            CHILDCARE,
            DIETETICS,
            DERMATOLOGY,
            PHYSIOTHERAPY,
            GYNECOLOGY,
        ],
        access_types=[CHAT],
        country=france,
        languages=[french, english, spanish],
        onboarding_status=COMPLETED,
    ),
    MedicalAdminData(
        first_name="Pauline",
        last_name="Lotte",
        specialty=CHILDCARE_NURSE,
        avatar="http://eu.alan.uploads.s3.eu-central-1.amazonaws.com/manual_upload/9a0297eaf92f4f88a763c9fe3c954983_pauline-lotte.jpg",
        description="Je suis infirmière puéricultrice depuis 2007 et installée en libéral depuis 2018. J'interviens chez Alan en tant que spécialiste du sommeil.\nAprès 10 ans de pratique en hôpital pédiatrique et 1 an en direction de crèche, j'ai choisi de travailler en indépendante pour accompagner les parents au plus près de leur quotidien avec bébé.\nJe me suis spécialisée dans plusieurs domaines, et plus spécialement le sommeil du tout-petit.\nJe suis maman d'une petite fille depuis 2019.",
        experiences=[
            MedicalAdminExperienceData(
                title="2006 - Diplôme d'Etat d'Infirmière",
                subtitle="IFSI de Reims",
                index=10,
            ),
            MedicalAdminExperienceData(
                title="2007 - Diplôme d'Etat de Puéricultrice",
                subtitle="Ecole de puéricultrice de Reims",
                index=9,
            ),
            MedicalAdminExperienceData(
                title="2013 - Diplôme Universitaire de prise en charge de la douleur de l'enfant",
                subtitle=None,
                index=8,
            ),
            MedicalAdminExperienceData(
                title="2019 - Instructrice Dunstan Baby Langage",
                subtitle="Dunstan Baby Langage France",
                index=7,
            ),
            MedicalAdminExperienceData(
                title="2019 - Educateur Montessori",
                subtitle="Enfance Positive",
                index=6,
            ),
            MedicalAdminExperienceData(
                title="2020 - Animateur de Signes Associés à la Parole",
                subtitle="Eveil et Signes",
                index=5,
            ),
            MedicalAdminExperienceData(
                title="2020 - Formation Nutrition pédiatrique",
                subtitle="EPM nutrition",
                index=4,
            ),
            MedicalAdminExperienceData(
                title="2020 - Formation au sommeil du bébé de 0 à 5 ans",
                subtitle="M. Bilodeau",
                index=3,
            ),
            MedicalAdminExperienceData(
                title="2020 - Comprendre et accompagner le sommeil de l'enfant",
                subtitle="Mandy Roman",
                index=2,
            ),
            MedicalAdminExperienceData(
                title="2021 - Formation consultation du sommeil, alimentation et rythmes de 0 à 6 ans en avril 2021",
                subtitle="Prosom",
                index=1,
            ),
            MedicalAdminExperienceData(
                title="2021 - Formation sommeil du tout petit et accompagnement parental",
                subtitle="Ingrid Bayot",
                index=0,
            ),
        ],
        apps_displayed_in=[alan_insurance],
        accessible_conversation_specialties=[CHILDCARE],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[dutch, english],
        onboarding_status=COMPLETED,
    ),
    MedicalAdminData(
        first_name="Margaux",
        last_name="Degen",
        specialty=PSYCHOLOGIST,
        avatar="http://eu.alan.uploads.s3.eu-central-1.amazonaws.com/manual_upload/9d775ac221a84812a3cc18bae63b7766_doctor_beaucote_headshot.jpg",
        description="Je suis psychologue clinicienne et j'ai rejoint Alan pour aider les membres à prendre soin de leur santé mentale au quotidien.\nFormée à Paris et spécialisée en thérapies cognitivo-comportementales (TCC), j'accompagne mes patients sur les sujets de stress, sommeil, anxiété et bien-être au travail.\nJe propose des séances d'orientation et un suivi thérapeutique en visio.",
        first_message_body="Bonjour, je suis Margaux, psychologue chez Alan. Dites-moi ce qui vous amène et on regardera ensemble comment je peux vous aider.",
        experiences=[
            MedicalAdminExperienceData(
                title="DU Thérapies cognitivo-comportementales",
                subtitle="Université Paris Descartes",
                index=2,
            ),
            MedicalAdminExperienceData(
                title="Master 2 Psychologie clinique",
                subtitle="Université Paris Cité",
                index=1,
            ),
            MedicalAdminExperienceData(
                title="Licence de Psychologie",
                subtitle="Université Paris Nanterre",
                index=0,
            ),
        ],
        accessible_conversation_specialties=[
            PSYCHOLOGY,
            THERAPY,
        ],
        clinic_role=CLINIC_ADMIN,
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT, VIDEO],
        answers_to_proactive_conversation_topics=[
            MENTAL_HEALTH,
            MENTAL_WELLBEING,
            STRESS,
            SLEEP,
        ],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="148187763",
    ),
    MedicalAdminData(
        first_name="Emile",
        last_name="Montrois",
        specialty=PSYCHOLOGIST,
        accessible_conversation_specialties=[
            PSYCHOLOGY,
            THERAPY,
        ],
        access_types=[VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="148184344",
    ),
    MedicalAdminData(
        first_name="Florian",
        last_name="Ghiazza",
        specialty=PHYSIOTHERAPIST,
        accessible_conversation_specialties=[
            PHYSIOTHERAPY,
            BACK_PAIN,
            EMERGENCY_PHYSIOTHERAPY,
        ],
        access_types=[CHAT, VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="OTiPilFASx-0yBrP2HtLrQ",
        prod_id="b65af61b-c455-4c5f-a678-164d165d1f45",
    ),
    MedicalAdminData(
        first_name="Diego",
        last_name="Ferral-Toro",
        specialty=PHYSIOTHERAPIST,
        accessible_conversation_specialties=[
            PHYSIOTHERAPY,
            BACK_PAIN,
            EMERGENCY_PHYSIOTHERAPY,
        ],
        access_types=[CHAT, VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_ES],
        country=spain,
        languages=[spanish, english],
        onboarding_status=COMPLETED,
        dato_id="XSdL4ehETM-owb_20xEmhg",
        prod_id="18eb92d9-3271-4286-91dc-a4e1a8ac5de2",
    ),
    MedicalAdminData(
        first_name="Diane",
        last_name="Coomans",
        specialty=PHYSIOTHERAPIST,
        accessible_conversation_specialties=[
            PHYSIOTHERAPY,
            BACK_PAIN,
            EMERGENCY_PHYSIOTHERAPY,
        ],
        access_types=[CHAT, VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_BE],
        country=belgium,
        languages=[dutch, english],
        onboarding_status=COMPLETED,
        dato_id="OXi_GJK7TziPCWlkkFWQCw",
        prod_id="59ce8029-2aa1-4ff5-81b1-25156ebcf5f1",
    ),
    MedicalAdminData(
        first_name="Robin",
        last_name="Vervaeke",
        specialty=PHYSIOTHERAPIST,
        accessible_conversation_specialties=[
            PHYSIOTHERAPY,
            BACK_PAIN,
            EMERGENCY_PHYSIOTHERAPY,
        ],
        access_types=[CHAT, VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR, ALAN_ES, ALAN_BE],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="R03pRAdAR1-Hq7_B4A0pAw",
        prod_id="59584887-47a7-464d-86c7-4f1a15299eaa",
    ),
    MedicalAdminData(
        first_name="Olivier",
        last_name="Delarras",
        specialty=GENERAL_PRACTITIONER,
        accessible_conversation_specialties=[
            GENERAL_MEDICINE,
            CONSULTATION,
            PEDIATRICS,
            CHILDCARE,
            DIETETICS,
            DERMATOLOGY,
            PHYSIOTHERAPY,
            GYNECOLOGY,
        ],
        access_types=[CHAT, VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR, ALAN_ES, ALAN_BE],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="RunHY9MqRXOl4ti7fuhoTw",
        prod_id="3c7c88e9-0794-4d23-9a32-002e75ca1f60",
    ),
    MedicalAdminData(
        first_name="Sophie",
        last_name="Vandenberghe",
        specialty=PSYCHOLOGIST,
        accessible_conversation_specialties=[
            PSYCHOLOGY,
            THERAPY,
        ],
        access_types=[CHAT, VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_BE],
        country=belgium,
        languages=[dutch, french, english],
        onboarding_status=COMPLETED,
        dato_id="141232141",
    ),
    MedicalAdminData(
        first_name="Lucas",
        last_name="De Smet",
        specialty=GENERAL_PRACTITIONER,
        accessible_conversation_specialties=[
            GENERAL_MEDICINE
        ],
        access_types=[CHAT],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_BE],
        country=belgium,
        languages=[dutch, french, english],
        onboarding_status=COMPLETED,
        dato_id="142690430",
    ),
    MedicalAdminData(
        first_name="Lucía",
        last_name="Martínez",
        specialty=PSYCHOLOGIST,
        accessible_conversation_specialties=[
            PSYCHOLOGY,
            THERAPY,
        ],
        access_types=[CHAT, VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_ES],
        country=spain,
        languages=[spanish, english],
        onboarding_status=COMPLETED,
        dato_id="121815108",
    ),
    MedicalAdminData(
        first_name="Maxime",
        last_name="Tremblay",
        specialty=PSYCHOLOGIST,
        accessible_conversation_specialties=[
            PSYCHOLOGY,
            THERAPY,
        ],
        access_types=[CHAT, VIDEO],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_CA],
        country=canada,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="122092169",
    ),
    MedicalAdminData(
        first_name="Patrick",
        last_name="Pediatre",
        specialty=PEDIATRICIAN,
        accessible_conversation_specialties=[
            PEDIATRICS,
            CHILDCARE,
        ],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="149004586",
    ),
    MedicalAdminData(
        first_name="Delphine",
        last_name="Dietetique",
        specialty=DIETITIAN,
        accessible_conversation_specialties=[DIETETICS],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        answers_to_proactive_conversation_topics=[
            NUTRITION
        ],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="122579720",
    ),
    MedicalAdminData(
        first_name="Damien",
        last_name="Derma",
        specialty=DERMATOLOGIST,
        accessible_conversation_specialties=[DERMATOLOGY],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="141710814",
    ),
    MedicalAdminData(
        first_name="Gisèle",
        last_name="Gyneco",
        specialty=GYNECOLOGIST,
        accessible_conversation_specialties=[GYNECOLOGY],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="147383847",
    ),
    MedicalAdminData(
        first_name="Nora",
        last_name="Infirmiere",
        specialty=NURSE,
        accessible_conversation_specialties=[
            GENERAL_MEDICINE
        ],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="81587618",
    ),
    MedicalAdminData(
        first_name="Charles",
        last_name="Coach",
        specialty=COACH,
        accessible_conversation_specialties=[],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[VIDEO],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="109915791",
    ),
    MedicalAdminData(
        first_name="Odile",
        last_name="Opticien",
        specialty=OPTICIAN,
        accessible_conversation_specialties=[OPTIC],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="141518431",
    ),
    MedicalAdminData(
        first_name="Sarah",
        last_name="Sexologue",
        specialty=SEXOLOGIST,
        accessible_conversation_specialties=[SEXOLOGY],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="120171054",
    ),
    MedicalAdminData(
        first_name="Olivia",
        last_name="OpsDemo",
        specialty=GENERAL_PRACTITIONER,
        accessible_conversation_specialties=[
            GENERAL_MEDICINE
        ],
        apps_displayed_in=[alan_insurance],
        has_access_to_app_ids=[ALAN_FR],
        access_types=[CHAT],
        country=france,
        languages=[french, english],
        onboarding_status=COMPLETED,
        dato_id="122939312",
        clinic_role=CLINIC_OPS,
    ),
]

medical_conversation

close_old_answered_medical_conversations

close_old_answered_medical_conversations(
    age_for_gp, age_for_non_gp, dry_run
)

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
@command_with_dry_run
@click.option(
    "--age-for-gp", type=int, help="Minimum age in days to close gp conversations"
)
@click.option(
    "--age-for-non-gp",
    type=int,
    help="Minimum age in days to close non gp conversations",
)
def close_old_answered_medical_conversations(  # noqa: D103
    age_for_gp: int,
    age_for_non_gp: int,
    dry_run: bool,
) -> None:
    from components.clinic.internal.business_logic.medical_conversation import (
        close_old_answered_medical_conversations,
    )

    close_old_answered_medical_conversations(
        age_for_gp=age_for_gp,
        age_for_non_gp=age_for_non_gp,
        dry_run=dry_run,
    )

close_old_therapy_session_conversations

close_old_therapy_session_conversations(
    age_for_orientation, age_for_therapy, dry_run
)

Mark inactive therapy/orientation conversations as closable for inactivity.

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
@command_with_dry_run
@click.option(
    "--age-for-orientation",
    type=int,
    default=30,
    show_default=True,
    help="Minimum age in days to close orientation-only therapy conversations",
)
@click.option(
    "--age-for-therapy",
    type=int,
    default=90,
    show_default=True,
    help="Minimum age in days to close therapy conversations (also wins over orientation when mixed)",
)
def close_old_therapy_session_conversations(
    age_for_orientation: int,
    age_for_therapy: int,
    dry_run: bool,
) -> None:
    """Mark inactive therapy/orientation conversations as closable for inactivity."""
    from components.clinic.internal.business_logic.medical_conversation import (
        close_old_therapy_session_conversations,
    )

    close_old_therapy_session_conversations(
        age_for_orientation=age_for_orientation,
        age_for_therapy=age_for_therapy,
        dry_run=dry_run,
    )

create_fake_conversations

create_fake_conversations(count, specialty, app, is_closed)

Create fake conversations for testing purposes only - count: number of fake conversations to create - specialty: medical specialty of the fake conversations to create - app: app of the fake conversations to create - is_closed: whether the fake conversations should be closed or not

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
@click.option(
    "-c", "--count", default=50, help="Number of fake conversations to create"
)
@click.option(
    "-s",
    "--specialty",
    default=None,
    help="Medical specialty of fake conversations to create",
)
@click.option(
    "-a",
    "--app",
    default=None,
    help="App of fake conversations to create",
)
@click.option(
    "--is-closed",
    type=bool,
    default=False,
    help="App of fake conversations to create",
)
@do_not_run_in_prod
def create_fake_conversations(
    count: int, specialty: str, app: str, is_closed: bool
) -> None:
    """
    Create fake conversations for testing purposes only
    - count: number of fake conversations to create
    - specialty: medical specialty of the fake conversations to create
    - app: app of the fake conversations to create
    - is_closed: whether the fake conversations should be closed or not
    """
    _create_fake_conversations(
        count=count, specialty=specialty, app=app, is_closed=is_closed
    )

erase_all_conversation_data

erase_all_conversation_data()

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
@do_not_run_in_prod
def erase_all_conversation_data() -> None:  # noqa: D103
    from components.clinic.internal.models.medical_conversation import (
        MedicalConversation,
    )
    from components.clinic.internal.models.medical_conversation_ai_suggestions_result import (
        MedicalConversationAiSuggestionsResult,
    )
    from components.clinic.internal.models.medical_conversation_attachment import (
        MedicalConversationAttachment,
    )
    from components.clinic.internal.models.medical_conversation_bookmark import (
        MedicalConversationBookmark,
    )
    from components.clinic.internal.models.medical_conversation_follow_up import (
        MedicalConversationFollowUp,
    )
    from components.clinic.internal.models.medical_conversation_part import (
        MedicalConversationPart,
    )
    from components.clinic.internal.models.medical_conversation_rating_v2 import (
        MedicalConversationRatingV2,
    )
    from components.clinic.internal.models.medical_conversation_redirection import (
        MedicalConversationRedirection,
    )
    from components.clinic.internal.models.medical_conversation_redirection_medical_conversation_part import (
        MedicalConversationRedirectionMedicalConversationPart,
    )
    from components.clinic.internal.models.medical_conversation_review_from_medical_admin import (
        MedicalConversationReviewFromMedicalAdmin,
    )
    from components.clinic.internal.models.medical_conversation_tag_mapping import (
        MedicalConversationTagMapping,
    )

    if not click.confirm("This will erase all conversation data, are you sure?"):
        return

    current_session.query(MedicalConversationAiSuggestionsResult).delete()  # noqa: ALN085
    current_session.query(MedicalConversationReviewFromMedicalAdmin).delete()  # noqa: ALN085
    current_session.query(  # noqa: ALN085
        MedicalConversationRedirectionMedicalConversationPart
    ).delete()
    current_session.query(MedicalConversationRedirection).delete()  # noqa: ALN085
    current_session.query(MedicalConversationBookmark).delete()  # noqa: ALN085
    current_session.query(MedicalConversationFollowUp).delete()  # noqa: ALN085
    current_session.query(MedicalConversationTagMapping).delete()  # noqa: ALN085
    current_session.query(MedicalConversationRatingV2).delete()  # noqa: ALN085
    current_session.query(MedicalConversationAttachment).delete()  # noqa: ALN085
    current_session.query(MedicalConversationPart).delete()  # noqa: ALN085
    current_session.query(MedicalConversation).delete()  # noqa: ALN085

    current_session.commit()

faker module-attribute

faker = Faker('fr_FR')

mark_conversations_for_retention_deletion

mark_conversations_for_retention_deletion(dry_run)

Set deleted_at on BE GP video-consultation conversations (5-year retention).

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
@command_with_dry_run
def mark_conversations_for_retention_deletion(dry_run: bool) -> None:
    """Set deleted_at on BE GP video-consultation conversations (5-year retention)."""
    from components.clinic.internal.business_logic.medical_conversation_retention import (
        mark_be_consultation_conversations_for_retention_deletion,
    )

    result = mark_be_consultation_conversations_for_retention_deletion(
        commit=not dry_run
    )
    current_logger.info(
        "retention deletion marking complete",
        dry_run=dry_run,
        total_candidates=result.total_candidates,
        immediately_hidden=result.immediately_hidden,
        marked=result.marked,
    )

notify_stale_consultation_conversations

notify_stale_consultation_conversations(dry_run)

Notify members in stale consultation conversations (36h without HP reply post-TLC).

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
@command_with_dry_run
def notify_stale_consultation_conversations(dry_run: bool) -> None:
    """Notify members in stale consultation conversations (36h without HP reply post-TLC)."""
    from components.clinic.internal.business_logic.medical_conversation import (
        notify_stale_consultation_conversations as _notify,
    )

    _notify(dry_run=dry_run)

resolve_closable_conversations

resolve_closable_conversations()

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
def resolve_closable_conversations() -> None:  # noqa: D103
    from components.clinic.internal.business_logic.medical_conversation import (
        resolve_closable_conversations as _resolve_closable_conversations,
    )

    _resolve_closable_conversations()

send_pending_proactive_conversations

send_pending_proactive_conversations(dry_run)

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
@command_with_dry_run
def send_pending_proactive_conversations(dry_run: bool) -> None:  # noqa: D103
    from components.clinic.internal.business_logic.medical_conversation_proactive import (
        send_pending_proactive_conversations,
    )

    send_pending_proactive_conversations(commit=not dry_run)

update_active_after_for_conversations

update_active_after_for_conversations(
    dry_run, recently_modified_only
)

This command will update the active_after field on conversations. It's helpful for: - computing it the first time - resetting it from time to time, if we have a bug and we want to fix the values

Source code in components/clinic/public/commands/medical_conversation.py

@clinic_commands.command()
@command_with_dry_run
@click.option(
    "--recently-modified-only",
    type=bool,
    required=False,
    default=False,
    is_flag=True,
    help="Only look at recently modified conversations",
)
def update_active_after_for_conversations(
    dry_run: bool, recently_modified_only: bool
) -> None:
    """
    This command will update the active_after field on conversations.
    It's helpful for:
    - computing it the first time
    - resetting it from time to time, if we have a bug and we want to fix the values
    """
    from components.clinic.internal.business_logic.medical_conversation import (
        update_active_after_for_conversations as _update_active_after_for_conversations,
    )

    _update_active_after_for_conversations(
        commit=not dry_run, recently_modified_only=recently_modified_only
    )
    if dry_run:
        # Just being safe
        current_session.rollback()

setup

flask clinic setup — bootstrap the local Alan Clinic environment.

This file is the orchestrator: it owns the Click command and the order of phases. The phase functions themselves live in the setup_steps/ package as siblings:

• setup_steps.helpers — shared utilities (run_step, email parsing, User lookup)
• setup_steps.printer — pretty progress blocks (success / action / error / info)
• setup_steps.preflight — Click-callback pre-flight checks (e.g. Postgres up)
• setup_steps.country_config — CountryConfig registry (used by upstack PRs)
• setup_steps.init_steps — encryption, dataset admins, chat bot, booking cache
• setup_steps.preconfigure_booking_hp — assign mock dato_id to the local Clinic Admin (booking HP)
• setup_steps.test_data_generator — hand off protagonist creation to the TDG + poll for the user
• setup_steps.fake_conversations — optional fake convs (volume test)
• setup_steps.post_setup — final manual-steps checklist

setup

setup(
    country,
    password,
    alaner_email,
    dato_id_mock,
    company_name,
    colleague_count,
    with_therapist_oauth,
    with_protagonist_seeds,
    with_fake_conversations,
    fake_conversations_count,
    yes,
)

Bootstrap the local Alan Clinic environment.

Wipes and re-creates encryption keys, the medical admin dataset (with one admin per specialty + 1 CLINIC_OPS, plus-tagged off your AWS IAM identity), the medical chat bot, the booking next-availability cache, and pre-configures the Clinic Admin as the bookable therapy HP. Optionally generates fake conversations.

Source code in components/clinic/public/commands/setup.py

@clinic_commands.command()
@click.option(
    "--country",
    type=click.Choice(list(COUNTRIES)),
    default="fr",
    show_default=True,
    help="Target country. Only countries with a wired `CountryConfig` in setup_steps.country_config show up here.",
)
@click.option(
    "--password",
    type=str,
    default="azerty",
    show_default=True,
    help="Password for the generated medical admin accounts.",
)
@click.option(
    "--alaner-email",
    type=str,
    default=lambda: aws_user_email(),
    show_default=True,
    help="Your real Alan email — base for the plus-tagged admin emails. Defaults to your AWS IAM identity (`<iam-username>@alan.eu`); pass it explicitly to override, or it'll be asked interactively if AWS isn't available.",
)
@click.option(
    "--dato-id-mock",
    type=str,
    default=DEFAULT_DATO_ID_MOCK,
    show_default=True,
    help="DatoCMS id assigned to the Clinic Admin locally so their HP card is hydrated. The default is a known-good live id.",
)
@click.option(
    "--company-name",
    type=str,
    default="",
    show_default=False,
    help="Demo company the TDG will create. Defaults to `<Local> Co` derived from your alaner email (e.g. `Alex Temina Co`).",
)
@click.option(
    "--colleague-count",
    type=int,
    default=DEFAULT_COLLEAGUE_COUNT,
    show_default=True,
    help="Number of additional employees the TDG will seed alongside the protagonist.",
)
@click.option(
    "--with-therapist-oauth",
    is_flag=True,
    default=False,
    help="Open marmot for the dev to complete Google OAuth + create a calendar slot for the Clinic Admin.",
)
@click.option(
    "--with-protagonist-seeds",
    is_flag=True,
    default=False,
    help="Seed historical conversations + future teleconsultations for the protagonist.",
)
@click.option(
    "--with-fake-conversations",
    is_flag=True,
    default=False,
    help="Generate fake medical conversations after the core setup.",
)
@click.option(
    "--fake-conversations-count",
    type=int,
    default=50,
    show_default=True,
    help="How many fake conversations to generate when --with-fake-conversations is set.",
)
@click.option(
    "--yes",
    is_flag=True,
    default=False,
    help="Skip the destructive-actions confirmation prompt.",
)

##############
## SETUP
##############
def setup(
    country: str,
    password: str,
    alaner_email: str,
    dato_id_mock: str,
    company_name: str,
    colleague_count: int,
    with_therapist_oauth: bool,
    with_protagonist_seeds: bool,
    with_fake_conversations: bool,
    fake_conversations_count: int,
    yes: bool,
) -> None:
    """
    Bootstrap the local Alan Clinic environment.

    Wipes and re-creates encryption keys, the medical admin dataset (with one
    admin per specialty + 1 CLINIC_OPS, plus-tagged off your AWS IAM identity),
    the medical chat bot, the booking next-availability cache, and
    pre-configures the Clinic Admin as the bookable therapy HP. Optionally
    generates fake conversations.
    """
    if not is_development_mode():
        print_error("`flask clinic setup` is only available in development mode.")
        return

    if not yes:
        print_action(
            "Heads up — this is destructive. It will:",
            body=[
                "• DELETE every medical admin (doctor) and their pictures, descriptions, experiences.",
                "• REGENERATE the encryption keys from scratch — any existing encrypted",
                "  conversation becomes unreadable.",
                "• DELETE the booking next-availability cache so it gets rebuilt.",
                "",
                "What's preserved: companies, members, conversations not tied to the wiped admins.",
            ],
        )
        click.confirm("Continue?", abort=True)

    country_config = COUNTRIES[country]
    confirmed_alaner_email = _resolve_alaner_email(alaner_email)
    protagonist_email = derive_protagonist_email(confirmed_alaner_email)

    run_step(
        "TDG: create protagonist via the Test Data Generator",
        lambda: step_create_protagonist_via_tdg(
            country=country_config,
            protagonist_email=protagonist_email,
            company_name=company_name,
            colleague_count=colleague_count,
        ),
    )
    run_step(
        "Clinic: backfill protagonist ClinicUser (+consent)",
        lambda: step_ensure_protagonist_clinic_user(
            protagonist_email=protagonist_email
        ),
    )

    run_step(
        "Clinic: create medical admins (dataset)",
        lambda: step_create_medical_admins(
            password=password, alaner_email=confirmed_alaner_email
        ),
    )

    run_step("Clinic: create medical chat bot", step_create_medical_chat_bot)

    run_step(
        "Encryption: regenerate keys + doctor group (admins enrolled)",
        step_encryption,
    )

    # Refresh the booking cache BEFORE we pre-configure no oauth errors during the refresh.
    run_step("Booking: refresh next-availability cache", step_update_booking_cache)

    run_step(
        "Booking: pre-configure Clinic Admin (dato_id only, no OAuth)",
        lambda: step_preconfigure_booking_for_therapy_hp(dato_id=dato_id_mock),
    )

    if with_therapist_oauth:
        run_step(
            "Booking: complete Google OAuth + calendar slot (interactive)",
            lambda: step_setup_therapist_oauth_interactive(country=country_config),
        )

    if with_protagonist_seeds:
        run_step(
            "Protagonist: seed historical conversations",
            lambda: step_seed_user_conversations(user_email=protagonist_email),
        )
        run_step(
            "Protagonist: seed future teleconsultations",
            lambda: step_seed_open_teleconsultations(user_email=protagonist_email),
        )

    if with_fake_conversations:
        run_step(
            f"Fake data: {fake_conversations_count} medical conversations",
            lambda: step_create_fake_conversations(count=fake_conversations_count),
        )

    print_manual_post_setup_checklist(
        country=country_config,
        password=password,
        protagonist_email=protagonist_email,
        alaner_email=confirmed_alaner_email,
        therapist_oauth_done=with_therapist_oauth,
    )

setup_steps

country_config

Country abstraction for flask clinic setup.

Every piece of country-specific information lives here, so the orchestrator and the phase steps stay country-agnostic. Each phase function takes a CountryConfig and reads what it needs from it; the orchestrator picks the right config from the --country flag.

Adding a country = adding one more CountryConfig instance and registering it in COUNTRIES. The Click --country flag's Choice is auto-derived from this dict, so newly registered countries appear in --help immediately.

COUNTRIES module-attribute

COUNTRIES = {name: FR}

CountryConfig dataclass

CountryConfig(
    name,
    app_name,
    default_timezone,
    medical_admin_country,
    default_admin_languages,
    tdg_base_url="",
    marmot_base_url="",
    tdg_protagonist_yaml_template="",
)

Everything country-specific the setup needs, in one declarative block.

Medical admins always live behind the FR User model (doctor-chat runs on fr_api), so there is no per-country override for the User class or the create_or_assign helper. The fields here are what genuinely varies between countries: app id, timezone, languages, and the TDG URLs.

app_name instance-attribute

app_name

default_admin_languages instance-attribute

default_admin_languages

default_timezone instance-attribute

default_timezone

marmot_base_url class-attribute instance-attribute

marmot_base_url = ''

medical_admin_country instance-attribute

medical_admin_country

name instance-attribute

name

render_tdg_protagonist_yaml

render_tdg_protagonist_yaml(
    *, protagonist_email, company_name, colleague_count
)

Render the TDG YAML with all caller-supplied substitutions filled in.

Source code in components/clinic/public/commands/setup_steps/country_config.py

def render_tdg_protagonist_yaml(
    self, *, protagonist_email: str, company_name: str, colleague_count: int
) -> str:
    """Render the TDG YAML with all caller-supplied substitutions filled in."""
    return self.tdg_protagonist_yaml_template.format(
        protagonist_email=protagonist_email,
        company_name=company_name,
        colleague_count=colleague_count,
    )

tdg_base_url class-attribute instance-attribute

tdg_base_url = ''

tdg_protagonist_yaml_template class-attribute instance-attribute

tdg_protagonist_yaml_template = ''

FR module-attribute

FR = CountryConfig(
    name="fr",
    app_name=ALAN_FR,
    default_timezone="Europe/Paris",
    medical_admin_country=france,
    default_admin_languages=[french, english],
    tdg_base_url="http://localhost:8001",
    marmot_base_url="http://localhost:4001/marmot/fr/alan-clinic",
    tdg_protagonist_yaml_template=dedent(
        '        - ref: "alan_demo"\n          company:\n            name: "{company_name}"\n        - ref: "protagonist_enrollment"\n          enrollment:\n            contract: "ref:alan_demo.contracts[0]"\n            user__email: "{protagonist_email}"\n            user__first_name: "Demo"\n            user__last_name: "Member"\n        - ref: "colleague_employments"\n          count: {colleague_count}\n          employment:\n            company: "ref:alan_demo"\n        '
    ),
)

fake_conversations

Optional conversation-domain step: bulk-seed random fake medical conversations (--with-fake-conversations).

step_create_fake_conversations

step_create_fake_conversations(count)

Generate count random fake medical conversations across existing members (volume test).

Source code in components/clinic/public/commands/setup_steps/fake_conversations.py

def step_create_fake_conversations(count: int) -> None:
    """Generate `count` random fake medical conversations across existing members (volume test)."""
    from components.clinic.public.commands.medical_conversation import (
        _create_fake_conversations,
    )

    _create_fake_conversations(count=count, specialty=None, app=None, is_closed=False)

helpers

Shared helpers for the flask clinic setup command package: step runner, email parsing, and FR User resolution.

aws_user_email

aws_user_email()

Return <iam-username>@alan.eu, or empty string if AWS is unavailable.

Source code in components/clinic/public/commands/setup_steps/helpers.py

def aws_user_email() -> str:
    """Return `<iam-username>@alan.eu`, or empty string if AWS is unavailable."""
    try:
        from shared.services.aws import get_current_user

        username = get_current_user()
        return f"{username}@alan.eu" if username else ""
    except Exception:
        return ""

default_protagonist_email

default_protagonist_email()

Best-effort default protagonist email: AWS IAM identity + +main.member tag.

Returns empty string if AWS credentials are not available or the IAM identity does not look like a valid email — callers should fall back to a required-flag error in that case.

Source code in components/clinic/public/commands/setup_steps/helpers.py

def default_protagonist_email() -> str:
    """Best-effort default protagonist email: AWS IAM identity + `+main.member` tag.

    Returns empty string if AWS credentials are not available or the IAM
    identity does not look like a valid email — callers should fall back to
    a required-flag error in that case.
    """
    alaner = aws_user_email()
    if not alaner:
        return ""
    try:
        local, domain = split_email_local_domain(alaner)
        return f"{local}+main.member@{domain}"
    except click.UsageError:
        return ""

get_or_create_clinic_user_with_consent

get_or_create_clinic_user_with_consent(user_email)

Find the user → return their ClinicUser, creating one with consent if missing.

Raises if the underlying FR User doesn't exist yet (the caller is expected to have run the TDG step first). Stamps consent_given_at so the privacy toggle is ON out-of-the-box. The pivot row uses AppName.ALAN_FR — medical admins (and the local clinic protagonist) always live behind the FR User model.

Source code in components/clinic/public/commands/setup_steps/helpers.py

def get_or_create_clinic_user_with_consent(user_email: str) -> ClinicUser:
    """Find the user → return their `ClinicUser`, creating one with consent if missing.

    Raises if the underlying FR `User` doesn't exist yet (the caller is expected
    to have run the TDG step first). Stamps `consent_given_at` so the privacy
    toggle is ON out-of-the-box. The pivot row uses `AppName.ALAN_FR` —
    medical admins (and the local clinic protagonist) always live behind the
    FR User model.
    """
    from datetime import UTC, datetime

    from sqlalchemy import select

    from shared.helpers.app_name import AppName
    from shared.helpers.db import current_session

    user = get_user_by_email(user_email)
    if user is None:
        raise click.ClickException(
            f"User {user_email} not found — run "
            f"`flask clinic create_protagonist_via_tdg` first."
        )

    clinic_user = current_session.scalars(
        select(ClinicUser).where(
            ClinicUser.app_id == AppName.ALAN_FR,
            ClinicUser.app_user_id == str(user.id),
        )
    ).first()

    if clinic_user is None:
        clinic_user = ClinicUser(
            app_id=AppName.ALAN_FR,
            app_user_id=str(user.id),
            consent_given_at=datetime.now(UTC),
        )
        current_session.add(clinic_user)
        current_session.flush()
        return clinic_user

    if clinic_user.consent_given_at is None:
        clinic_user.consent_given_at = datetime.now(UTC)
        current_session.flush()
    return clinic_user

get_user_by_email

get_user_by_email(email)

Resolve a FR User by email.

Medical admins (and the local clinic protagonist) always sit behind the FR User model — doctor-chat runs on fr_api. We expire_all() before querying so subsequent polling loops see rows just inserted by an out-of-process operation (e.g. the TDG).

Source code in components/clinic/public/commands/setup_steps/helpers.py

def get_user_by_email(email: str) -> "User | None":
    """
    Resolve a FR User by email.

    Medical admins (and the local clinic protagonist) always sit behind the
    FR User model — doctor-chat runs on `fr_api`. We `expire_all()` before
    querying so subsequent polling loops see rows just inserted by an
    out-of-process operation (e.g. the TDG).
    """
    from sqlalchemy import or_, select

    from components.fr.internal.models.user import User  # noqa: ALN039,ALN069
    from components.global_profile.internal.models.profile import (  # noqa: ALN039,ALN069
        ProfileModel,
    )
    from shared.helpers.db import current_session

    current_session.expire_all()

    return current_session.scalars(
        select(User)
        .outerjoin(ProfileModel, ProfileModel.id == User.profile_id)
        .where(
            or_(
                User._email == email,  # noqa: ALN027
                ProfileModel.email == email,
            )
        )
    ).first()

open_browser

open_browser(url)

Try to open url in the default browser. Returns False on failure.

Source code in components/clinic/public/commands/setup_steps/helpers.py

def open_browser(url: str) -> bool:
    """Try to open `url` in the default browser. Returns False on failure."""
    try:
        return webbrowser.open(url, new=2)
    except webbrowser.Error:
        return False

run_step

run_step(label, fn)

Run one labelled phase of the setup; failures are reported but don't abort.

Source code in components/clinic/public/commands/setup_steps/helpers.py

def run_step(label: str, fn: Callable[[], None]) -> None:
    """Run one labelled phase of the setup; failures are reported but don't abort."""
    click.secho(f"\n▶ {label}", fg="cyan", bold=True)

    try:
        fn()
        click.secho(f"✓ {label}", fg="green")
    except (click.Abort, KeyboardInterrupt):
        raise
    except Exception as exc:
        click.secho(f"✗ {label}: {exc}", fg="red", err=True)

split_email_local_domain

split_email_local_domain(email)

Split local+tag@domain into (local, domain) — drops any pre-existing +tag.

Source code in components/clinic/public/commands/setup_steps/helpers.py

def split_email_local_domain(email: str) -> tuple[str, str]:
    """Split `local+tag@domain` into `(local, domain)` — drops any pre-existing +tag."""
    if "@" not in email:
        raise click.UsageError(f"Invalid email: {email}")
    local, _, domain = email.partition("@")
    base_local = local.split("+", 1)[0]
    return base_local, domain

init_steps

Phase: bootstrap. Always-run baseline steps — encryption keys, the medical admin dataset, the chat bot, and the booking next-availability cache.

step_create_medical_admins

step_create_medical_admins(*, password, alaner_email)

Truncate + re-create every medical admin from the local dataset.

Each admin gets a plus-tagged login email derived from alaner_email (<local>+<lastname>@<domain>) so mails land in the developer's inbox. Medical admins always live behind the FR User model — doctor-chat runs on fr_api.

Source code in components/clinic/public/commands/setup_steps/init_steps.py

def step_create_medical_admins(*, password: str, alaner_email: str) -> None:
    """Truncate + re-create every medical admin from the local dataset.

    Each admin gets a plus-tagged login email derived from `alaner_email`
    (`<local>+<lastname>@<domain>`) so mails land in the developer's inbox.
    Medical admins always live behind the FR User model — doctor-chat runs
    on `fr_api`.
    """
    from components.clinic.public.commands.medical_admins import _create_medical_admins

    _create_medical_admins(password=password, alaner_email=alaner_email, dry_run=False)

step_create_medical_chat_bot

step_create_medical_chat_bot()

Idempotently create the system clinic_user backing the medical chat bot.

Source code in components/clinic/public/commands/setup_steps/init_steps.py

def step_create_medical_chat_bot() -> None:
    """Idempotently create the system clinic_user backing the medical chat bot."""
    from components.clinic.internal.business_logic.medical_chat_bot import (
        create_medical_chat_bot_clinic_user,
        medical_chat_bot_clinic_user_exists,
    )

    if medical_chat_bot_clinic_user_exists():
        click.echo("Medical chat bot already exists, skipping.")
        return

    create_medical_chat_bot_clinic_user()

step_encryption

step_encryption()

Regenerate the encryption keys + doctor group from scratch.

Source code in components/clinic/public/commands/setup_steps/init_steps.py

def step_encryption() -> None:
    """Regenerate the encryption keys + doctor group from scratch."""
    from components.encryption.public.commands import _generate_initial_keys

    _generate_initial_keys(clean_first=True)

step_update_booking_cache

step_update_booking_cache()

Refresh cached_next_availability on every TherapistBookingTherapist.

Source code in components/clinic/public/commands/setup_steps/init_steps.py

def step_update_booking_cache() -> None:
    """Refresh `cached_next_availability` on every TherapistBookingTherapist."""
    from components.clinic.internal.booking.business_logic.therapists import (
        update_cached_next_availability_of_all_therapists,
    )

    update_cached_next_availability_of_all_therapists(commit=True)

post_setup

Phase: end-of-run checklist. Prints the manual steps still required after flask clinic setup finishes — RQ worker, mailer, frontend, marmot HP booking config, doctor-chat login, and the member-app credentials.

print_manual_post_setup_checklist

print_manual_post_setup_checklist(
    *,
    country,
    password,
    protagonist_email,
    alaner_email,
    therapist_oauth_done
)

Print the post-setup checklist with concrete credentials per HP and member.

Source code in components/clinic/public/commands/setup_steps/post_setup.py

def print_manual_post_setup_checklist(
    *,
    country: "CountryConfig",
    password: str,
    protagonist_email: str,
    alaner_email: str,
    therapist_oauth_done: bool,
) -> None:
    """Print the post-setup checklist with concrete credentials per HP and member."""
    from components.clinic.internal.enums.medical_admin_role import MedicalAdminRole
    from components.clinic.public.commands.medical_admins_dataset import (
        RAW_MEDICAL_ADMINS,
    )

    local, domain = split_email_local_domain(alaner_email)
    targeted_admins = [
        raw
        for raw in RAW_MEDICAL_ADMINS
        if country.app_name in raw.has_access_to_app_ids
    ]
    # Clinic Admin first (it's the bookable therapy HP — most useful entry
    # point when poking around doctor-chat), the rest in dataset order.
    targeted_admins.sort(
        key=lambda raw: 0 if raw.clinic_role == MedicalAdminRole.CLINIC_ADMIN else 1
    )
    hp_creds = [
        (
            f"{raw.first_name} {raw.last_name}",
            f"{local}+{raw.last_name.lower().replace(' ', '')}@{domain}",
        )
        for raw in targeted_admins
    ]

    print_section_header("Manual steps left")

    print_info(
        "Run RQ worker (separate terminal)",
        body=["alan run --scope backend -- env APP=fr_api flask rq worker"],
    )
    print_info(
        "Run backend with mailer flag if you need outbound emails",
        body=["alan run --scope backend -- env APP=fr_api flask runserver -m"],
    )
    print_info(
        "Run frontend",
        body=["yarn workspace fr-server run dev"],
    )

    if not therapist_oauth_done:
        print_action(
            "HP booking config (Google OAuth) — pending",
            body=[
                "Re-run with --with-therapist-oauth, OR run on its own:",
                "  alan run --scope backend -- env APP=fr_api flask clinic setup_therapist_oauth",
            ],
        )

    print_info(
        "Member app — log in as the protagonist",
        body=[
            f"email:    {protagonist_email}",
            f"password: {password}  (whatever you set in the TDG blueprint)",
        ],
    )

    hp_login = [
        "URL:      http://localhost:4001/en/doctor-chat/login",
        f"password: {password}  (same for all HPs)",
        "",
        "Login emails per medical admin:",
    ]
    for full_name, email in hp_creds:
        hp_login.append(f"  - {full_name:<28} {email}")
    print_info("Doctor chat (HP interface)", body=hp_login)

    print_success(
        "Already automated for you",
        body=[
            "Clinic Admin dato_id, protagonist consent_given_at, default",
            "OpeningHours, doctor encryption group enrolment, optional",
            "protagonist conversations + future sessions.",
            "Company + employments come from the Test Data Generator.",
            "Reference: backend/components/clinic/README.md",
        ],
    )
    print_section_footer()

preconfigure_booking_hp

Phase: pre-configure the local "super-admin" HP for booking flows.

Assigns a mock dato_id to the therapy-capable Clinic Admin so the marmot card hydrates from DatoCMS.

Also exposes a standalone flask clinic preconfigure-booking-hp so the preconfig can be run on its own — identical surface as the flask clinic setup phase but reusable from scripts/CI.

DEFAULT_DATO_ID_MOCK module-attribute

DEFAULT_DATO_ID_MOCK = '141232141'

preconfigure_booking_hp

preconfigure_booking_hp(dato_id_mock)

Run the booking-HP preconfig step on its own, without the full flask clinic setup.

Source code in components/clinic/public/commands/setup_steps/preconfigure_booking_hp.py

@clinic_commands.command()
@click.option(
    "--dato-id-mock",
    type=str,
    default=DEFAULT_DATO_ID_MOCK,
    show_default=True,
    help="DatoCMS id assigned to the Clinic Admin locally so their HP card is hydrated.",
)
def preconfigure_booking_hp(dato_id_mock: str) -> None:
    """Run the booking-HP preconfig step on its own, without the full `flask clinic setup`."""
    if not is_development_mode():
        click.echo("This command is only available in development mode.")
        return
    step_preconfigure_booking_for_therapy_hp(dato_id=dato_id_mock)

step_preconfigure_booking_for_therapy_hp

step_preconfigure_booking_for_therapy_hp(*, dato_id)

Set the therapy Clinic Admin's dato_id so their card is hydrated from DatoCMS.

Therapy-only because it's the only booking flow that needs explicit activation (TherapistBookingTherapist + Google OAuth). Consultation (GP) and back_pain (physio) work out-of-the-box against the existing dataset admins — no preconfig needed.

To complete OAuth on this admin (or any other) afterwards, use flask clinic setup_therapist_oauth --admin-email <pro_email>.

Targets the first medical admin with clinic_role=CLINIC_ADMIN whose accessible_conversation_specialties includes THERAPY.

Source code in components/clinic/public/commands/setup_steps/preconfigure_booking_hp.py

def step_preconfigure_booking_for_therapy_hp(*, dato_id: str) -> None:
    """Set the therapy Clinic Admin's `dato_id` so their card is hydrated from DatoCMS.

    Therapy-only because it's the only booking flow that needs explicit
    activation (`TherapistBookingTherapist` + Google OAuth). Consultation
    (GP) and back_pain (physio) work out-of-the-box against the existing
    dataset admins — no preconfig needed.

    To complete OAuth on this admin (or any other) afterwards, use
    `flask clinic setup_therapist_oauth --admin-email <pro_email>`.

    Targets the first medical admin with `clinic_role=CLINIC_ADMIN` whose
    `accessible_conversation_specialties` includes THERAPY.
    """
    from components.clinic.internal.business_logic.queries.setup_queries import (
        get_therapy_clinic_admin,
    )
    from shared.helpers.db import current_session

    clinic_admin = get_therapy_clinic_admin()
    if clinic_admin is None:
        click.echo("No therapy-capable Clinic Admin found, skipping.")
        return

    if clinic_admin.dato_id is None:
        clinic_admin.dato_id = dato_id
        current_session.commit()
        click.echo(f"  + Clinic Admin.dato_id = {dato_id} (DatoCMS hydration)")
    else:
        click.echo(
            f"  Clinic Admin already has dato_id={clinic_admin.dato_id}, skipping."
        )

preflight

Pre-flight checks applied to the flask clinic setup Click callback BEFORE the shared audit decorator runs. Lives outside the regular phase steps (which run via run_step inside the command body) because the wrapping has to happen at module import time, on setup.callback itself.

require_local_postgres

require_local_postgres(callback)

Wrap the Click callback with a TCP pre-check against local Postgres.

A stopped local DB surfaces as a one-line friendly message with the exact devbox command. Without this wrapper, the shared audit decorator flushes a CommandLog row before our body runs and we get a 200-line SQLAlchemy traceback upstream of anything we could catch from inside setup().

Source code in components/clinic/public/commands/setup_steps/preflight.py

def require_local_postgres(callback: Callable[..., Any]) -> Callable[..., Any]:
    """Wrap the Click callback with a TCP pre-check against local Postgres.

    A stopped local DB surfaces as a one-line friendly message with the
    exact `devbox` command. Without this wrapper, the shared audit
    decorator flushes a `CommandLog` row before our body runs and we get
    a 200-line SQLAlchemy traceback upstream of anything we could catch
    from inside `setup()`.
    """

    def _wrapped(*args: Any, **kwargs: Any) -> Any:
        try:
            with socket.create_connection(("127.0.0.1", 5432), timeout=1):
                pass
        except OSError:
            print_error(
                "Postgres isn't reachable on 127.0.0.1:5432.",
                body=[
                    "Start your local services first:",
                    "    devbox services up -b",
                ],
            )
            raise click.Abort() from None
        return callback(*args, **kwargs)

    return _wrapped

printer

Pretty-printing helpers shared across setup_steps phases.

All blocks have the same shape: bold colored title → body lines (indented by two spaces) → colored separator line. The semantic functions pick the color so callers don't have to think about it:

print_success → green ("this went well")
print_action  → yellow ("you need to do something")
print_error   → red   ("this failed")
print_info    → cyan  ("here's a status / task in a guided checklist")

print_action

print_action(title, body=None)

Bold yellow title + body + yellow = separator. For action-required items.

Source code in components/clinic/public/commands/setup_steps/printer.py

def print_action(title: str, body: list[str] | None = None) -> None:
    """Bold yellow title + body + yellow `=` separator. For action-required items."""
    _print_block(title=title, body=body or [], color="yellow", separator="=")

print_error

print_error(title, body=None)

Bold red title + body + red = separator. For failures.

Source code in components/clinic/public/commands/setup_steps/printer.py

def print_error(title: str, body: list[str] | None = None) -> None:
    """Bold red title + body + red `=` separator. For failures."""
    _print_block(title=title, body=body or [], color="red", separator="=")

print_info

print_info(title, body=None)

Bold cyan title + body + cyan - separator. For neutral checklist items.

Source code in components/clinic/public/commands/setup_steps/printer.py

def print_info(title: str, body: list[str] | None = None) -> None:
    """Bold cyan title + body + cyan `-` separator. For neutral checklist items."""
    _print_block(title=title, body=body or [], color="cyan", separator="-")

print_section_footer

print_section_footer(color='cyan')

Close a multi-block section: = separator only.

Source code in components/clinic/public/commands/setup_steps/printer.py

def print_section_footer(color: str = "cyan") -> None:
    """Close a multi-block section: `=` separator only."""
    click.secho("=" * 76, fg=color)

print_section_header

print_section_header(title, color='cyan')

Open a multi-block section: bold title + = separator below.

Source code in components/clinic/public/commands/setup_steps/printer.py

def print_section_header(title: str, color: str = "cyan") -> None:
    """Open a multi-block section: bold title + `=` separator below."""
    click.echo()
    click.secho(title, fg=color, bold=True)
    click.secho("=" * 76, fg=color)

print_success

print_success(title, body=None)

Bold green title + body + green = separator. For positive outcomes.

Source code in components/clinic/public/commands/setup_steps/printer.py

def print_success(title: str, body: list[str] | None = None) -> None:
    """Bold green title + body + green `=` separator. For positive outcomes."""
    _print_block(title=title, body=body or [], color="green", separator="=")

seed_user_data

Phase: seed demo conversations + booking sessions for a member user.

Wired into flask clinic setup (the setup derives the user email from your alaner identity), and exposed standalone as flask clinic seed_user_data --user-email <email> so you can re-seed any member after the fact.

Prerequisites: - The user already exists in the DB (run create_protagonist_via_tdg first or have the TDG run elsewhere). - The medical admin dataset has been created (flask clinic setup).

The seed graph (GP / physio / therapy + specific MedicalConversationSpecialty values) is FR-centric by design — FR is the only country wired in CountryConfig today. When BE / ES / CA get added, lift the specialty specs into CountryConfig.seed_specialty_specs (new field) and have each step read from there. Single-source-of-truth follows the same pattern as tdg_protagonist_yaml_template.

seed_user_data

seed_user_data(user_email, therapy_admin_email)

Seed historical conversations + future teleconsultations for the user.

Source code in components/clinic/public/commands/setup_steps/seed_user_data.py

@clinic_commands.command()
@click.option(
    "--user-email",
    type=str,
    default=lambda: default_protagonist_email(),
    show_default=True,
    help="Email of the member to seed. Defaults to your AWS IAM identity plus-tagged with `+main.member`.",
)
@click.option(
    "--therapy-admin-email",
    type=str,
    default=None,
    help="Override the medical admin used for therapy convs + sessions (matched by `pro_email`). Defaults to the first CLINIC_ADMIN with THERAPY access — falls back to that if not found.",
)
def seed_user_data(user_email: str, therapy_admin_email: str | None) -> None:
    """Seed historical conversations + future teleconsultations for the user."""
    if not is_development_mode():
        print_error("This command is only available in development mode.")
        return
    if not user_email:
        raise click.UsageError(
            "A user email is required. Pass --user-email or configure AWS credentials."
        )

    step_seed_user_conversations(
        user_email=user_email,
        therapy_admin_email=therapy_admin_email,
    )
    step_seed_open_teleconsultations(
        user_email=user_email,
        therapy_admin_email=therapy_admin_email,
    )

step_seed_open_teleconsultations

step_seed_open_teleconsultations(
    *, user_email, therapy_admin_email=None
)

Create future confirmed TherapistBookingSession rows with the therapy admin.

Covers 1 orientation + 2 therapy + 1 consultation so testing each session type screen has data. created_at / confirmed_at antedated 6h so the derived chat appears active immediately when the dev logs in.

Skipped silently if the therapy admin has no TherapistBookingTherapist yet (real Google OAuth not done) — re-run after OAuth to populate them.

Source code in components/clinic/public/commands/setup_steps/seed_user_data.py

def step_seed_open_teleconsultations(
    *,
    user_email: str,
    therapy_admin_email: str | None = None,
) -> None:
    """Create future confirmed `TherapistBookingSession` rows with the therapy admin.

    Covers 1 orientation + 2 therapy + 1 consultation so testing each session
    type screen has data. `created_at` / `confirmed_at` antedated 6h so the
    derived chat appears active immediately when the dev logs in.

    Skipped silently if the therapy admin has no `TherapistBookingTherapist`
    yet (real Google OAuth not done) — re-run after OAuth to populate them.
    """
    from shared.helpers.db import current_session

    clinic_user = get_or_create_clinic_user_with_consent(user_email)
    therapy_admin = _resolve_therapy_admin(therapy_admin_email)
    if therapy_admin is None:
        raise click.ClickException(
            "No therapy-capable Clinic Admin found — run `flask clinic setup` first."
        )

    tbt_id = therapy_admin.therapist_booking_therapist_id
    if tbt_id is None:
        print_info(
            "Clinic Admin has no TherapistBookingTherapist (OAuth not done) — "
            "skipping future teleconsultations."
        )
        return

    now = datetime.now(UTC)
    schedule: list[tuple[TherapistBookingSessionType, datetime]] = [
        (TherapistBookingSessionType.orientation, now + timedelta(days=1, hours=9)),
        (TherapistBookingSessionType.therapy, now + timedelta(days=2, hours=10)),
        (TherapistBookingSessionType.therapy, now + timedelta(days=4, hours=14)),
        (TherapistBookingSessionType.consultation, now + timedelta(days=5, hours=11)),
    ]
    for session_type, starts_at in schedule:
        _create_booking_session(
            clinic_user=clinic_user,
            therapist_booking_therapist_id=tbt_id,
            session_type=session_type,
            starts_at=starts_at,
            conversation_id=None,
            confirmed=True,
            # Antedate creation so the chat derived from the booking is active
            # the moment the dev logs in (otherwise active_after is in the future).
            created_at=now - timedelta(hours=6),
        )

    current_session.commit()
    print_success("Seeded 4 future teleconsultations for the user.")

step_seed_user_conversations

step_seed_user_conversations(
    *, user_email, therapy_admin_email=None
)

Create historical conversations for the user, mixed states + specialties.

GP closed (35d), GP open recent, therapy + orientation session (75d, past), therapy + therapy session (50d, past), physio open recent. The therapy sessions are skipped if the therapy admin has no TherapistBookingTherapist yet (i.e. real OAuth not done) — the therapy convs are still created, just without a linked session.

Source code in components/clinic/public/commands/setup_steps/seed_user_data.py

def step_seed_user_conversations(
    *,
    user_email: str,
    therapy_admin_email: str | None = None,
) -> None:
    """Create historical conversations for the user, mixed states + specialties.

    GP closed (35d), GP open recent, therapy + orientation session (75d, past),
    therapy + therapy session (50d, past), physio open recent. The therapy
    sessions are skipped if the therapy admin has no `TherapistBookingTherapist`
    yet (i.e. real OAuth not done) — the therapy convs are still created, just
    without a linked session.
    """
    from shared.helpers.db import current_session

    clinic_user = get_or_create_clinic_user_with_consent(user_email)

    gp_admin = get_admin_by_specialty(MedicalAdminSpecialty.GENERAL_PRACTITIONER)
    physio_admin = get_admin_by_specialty(MedicalAdminSpecialty.PHYSIOTHERAPIST)
    therapy_admin = _resolve_therapy_admin(therapy_admin_email)
    if gp_admin is None or physio_admin is None or therapy_admin is None:
        raise click.ClickException(
            "Missing one of GP / physio / therapy-capable admins — run "
            "`flask clinic setup` first."
        )

    tbt_id = therapy_admin.therapist_booking_therapist_id
    if tbt_id is None:
        print_info(
            "Clinic Admin has no TherapistBookingTherapist (OAuth not done) — "
            "therapy conversations will be created without linked sessions."
        )
    now = datetime.now(UTC)

    specs = [
        _HistoricalConversationSpec(
            admin=gp_admin,
            specialty=MedicalConversationSpecialty.GENERAL_MEDICINE,
            age_days=35,
            is_closed=True,
        ),
        _HistoricalConversationSpec(
            admin=gp_admin,
            specialty=MedicalConversationSpecialty.GENERAL_MEDICINE,
            age_days=2,
        ),
        _HistoricalConversationSpec(
            admin=therapy_admin,
            specialty=MedicalConversationSpecialty.THERAPY,
            age_days=75,
            linked_session_type=TherapistBookingSessionType.orientation,
        ),
        _HistoricalConversationSpec(
            admin=therapy_admin,
            specialty=MedicalConversationSpecialty.THERAPY,
            age_days=50,
            linked_session_type=TherapistBookingSessionType.therapy,
        ),
        _HistoricalConversationSpec(
            admin=physio_admin,
            specialty=MedicalConversationSpecialty.PHYSIOTHERAPY,
            age_days=1,
        ),
    ]

    for spec in specs:
        conv = _create_conversation(
            clinic_user=clinic_user,
            medical_admin=spec.admin,
            specialty=spec.specialty,
            age_days=spec.age_days,
            is_closed=spec.is_closed,
        )
        if spec.linked_session_type is not None and tbt_id is not None:
            _create_booking_session(
                clinic_user=clinic_user,
                therapist_booking_therapist_id=tbt_id,
                session_type=spec.linked_session_type,
                starts_at=now - timedelta(days=spec.age_days),
                conversation_id=conv.id,
                confirmed=True,
            )

    current_session.commit()
    print_success(f"Seeded {len(specs)} historical conversations for the user.")

setup_therapist_oauth

Phase: guide the dev through the Google OAuth + booking activation for an HP.

This is the one step we can't bypass programmatically — marmot's "Activate booking" wizard opens a Google OAuth flow in the browser, and the dev has to manually create a calendar named "Alan Therapy" with at least one event matching the regex in booking/business_logic/google_calendar.py. After that, refreshing cached_next_availability exposes the HP as bookable in the member app.

Exposed standalone as flask clinic setup_therapist_oauth and wired into flask clinic setup via the --with-therapist-oauth flag.

DEFAULT_HEARTBEAT_INTERVAL_SECS module-attribute

DEFAULT_HEARTBEAT_INTERVAL_SECS = 20

DEFAULT_POLL_INTERVAL_SECS module-attribute

DEFAULT_POLL_INTERVAL_SECS = 3

DEFAULT_TIMEOUT_SECS module-attribute

DEFAULT_TIMEOUT_SECS = 300

setup_therapist_oauth

setup_therapist_oauth(country, admin_email)

Open marmot for the dev to complete Google OAuth + create a calendar slot.

Source code in components/clinic/public/commands/setup_steps/setup_therapist_oauth.py

@clinic_commands.command()
@click.option(
    "--country",
    type=click.Choice(list(COUNTRIES)),
    default="fr",
    show_default=True,
)
@click.option(
    "--admin-email",
    type=str,
    default=None,
    help="Override the medical admin to activate (matched by `pro_email`). Defaults to the first CLINIC_ADMIN with THERAPY access.",
)
def setup_therapist_oauth(country: str, admin_email: str | None) -> None:
    """Open marmot for the dev to complete Google OAuth + create a calendar slot."""
    if not is_development_mode():
        print_error("This command is only available in development mode.")
        return
    step_setup_therapist_oauth_interactive(
        country=COUNTRIES[country], admin_email=admin_email
    )

step_setup_therapist_oauth_interactive

step_setup_therapist_oauth_interactive(
    *,
    country,
    admin_email=None,
    timeout_secs=DEFAULT_TIMEOUT_SECS,
    poll_interval_secs=DEFAULT_POLL_INTERVAL_SECS,
    heartbeat_interval_secs=DEFAULT_HEARTBEAT_INTERVAL_SECS
)

Open marmot, then poll until the HP has a valid cached_next_availability.

The dev finishes booking activation in the browser (Google OAuth, calendar name "Alan Therapy", at least one event matching the slot regex). The polling refreshes the cache every poll_interval_secs and exits once a real availability is found — meaning OAuth is connected AND a slot is visible in the calendar.

Skipped silently if the country has no marmot_base_url configured.

Source code in components/clinic/public/commands/setup_steps/setup_therapist_oauth.py

def step_setup_therapist_oauth_interactive(
    *,
    country: "CountryConfig",
    admin_email: str | None = None,
    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
    poll_interval_secs: int = DEFAULT_POLL_INTERVAL_SECS,
    heartbeat_interval_secs: int = DEFAULT_HEARTBEAT_INTERVAL_SECS,
) -> None:
    """Open marmot, then poll until the HP has a valid `cached_next_availability`.

    The dev finishes booking activation in the browser (Google OAuth, calendar
    name "Alan Therapy", at least one event matching the slot regex). The
    polling refreshes the cache every `poll_interval_secs` and exits once a
    real availability is found — meaning OAuth is connected AND a slot is
    visible in the calendar.

    Skipped silently if the country has no `marmot_base_url` configured.
    """
    from components.clinic.internal.booking.business_logic.therapists import (
        update_cached_next_availability_of_all_therapists,
    )
    from shared.helpers.db import current_session

    if not country.marmot_base_url:
        print_info(f"Marmot not configured for country={country.name}, skipping.")
        return

    admin = _resolve_admin(admin_email)
    if admin is None:
        raise click.ClickException(
            "No therapy-capable Clinic Admin found — run `flask clinic setup` first."
        )

    admin_url = f"{country.marmot_base_url}/detail/{admin.id}"
    opened = open_browser(admin_url)
    print_action(
        f"Activate booking for {admin.first_name} {admin.last_name} in marmot:",
        body=[
            admin_url,
            "1. Complete the Google OAuth flow.",
            "2. Pick a Google calendar name (any name — you'll create a",
            "   Google Calendar with the same name in step 4).",
            "3. Use the Full Name + Email suggestions; tick 'Enabled booking'; Save.",
            "4. Open Google Calendar → create a calendar with the same name.",
            "5. In that calendar, create at least one event matching the slot",
            "   regex — e.g. `Alan Therapy (O)` tomorrow 09:00–09:30.",
            "(Browser opened automatically.)"
            if opened
            else "(Browser unavailable — open the URL above manually.)",
        ],
    )

    print_info(
        f"Polling marmot booking cache (timeout {timeout_secs}s)… "
        "create the OAuth + calendar event whenever you're ready."
    )
    start = time.monotonic()
    deadline = start + timeout_secs
    next_heartbeat = start + heartbeat_interval_secs
    while time.monotonic() < deadline:
        update_cached_next_availability_of_all_therapists(commit=True)
        current_session.expire_all()
        refreshed = current_session.get(MedicalAdmin, admin.id)
        tbt_id = refreshed.therapist_booking_therapist_id if refreshed else None
        next_availability = (
            refreshed.therapist_booking_therapist.cached_next_availability
            if refreshed and refreshed.therapist_booking_therapist
            else None
        )
        if tbt_id is not None and next_availability is not None:
            print_success(
                f"Booking active — next availability {next_availability.isoformat()}."
            )
            return

        now = time.monotonic()
        if now >= next_heartbeat:
            if tbt_id is None:
                hint = "OAuth not connected yet (no TherapistBookingTherapist)."
            else:
                hint = (
                    "OAuth OK, but no slot found yet — check 'Enabled booking' is "
                    "ticked in marmot and the GCal event matches the slot regex."
                )
            click.echo(f"  ⏳ {int(now - start)}s elapsed — {hint}")
            next_heartbeat = now + heartbeat_interval_secs
        time.sleep(poll_interval_secs)

    raise click.ClickException(
        f"Timed out after {timeout_secs}s waiting for booking activation. "
        f"Re-run `flask clinic setup_therapist_oauth` once OAuth + calendar slot "
        f"are in place."
    )

test_data_generator

Phase: hand off the protagonist creation to the Test Data Generator (TDG).

The TDG is a web tool (<base>/admin_tools/test_data_generator/new?fixture=...) that consumes a YAML and runs the matching factories to build the requested graph (company + employees + protagonist user). We can't drive it programmatically, but we can:

1. Build the country-specific YAML with the protagonist email substituted in.
2. base64-encode it and stuff it into the ?fixture= query param so the editor opens pre-filled.
3. Copy that URL to the dev's clipboard and print it.
4. Poll the DB until the protagonist user appears (TDG ran successfully).
5. Backfill the ClinicUser row + consent_given_at so the privacy toggle is on out-of-the-box.

Also exposes flask clinic generate-tdg-url as a standalone command so the URL can be re-generated without re-running the full setup (e.g. lost it from the clipboard).

DEFAULT_COLLEAGUE_COUNT module-attribute

DEFAULT_COLLEAGUE_COUNT = 4

DEFAULT_HEARTBEAT_INTERVAL_SECS module-attribute

DEFAULT_HEARTBEAT_INTERVAL_SECS = 20

DEFAULT_POLL_INTERVAL_SECS module-attribute

DEFAULT_POLL_INTERVAL_SECS = 3

DEFAULT_TIMEOUT_SECS module-attribute

DEFAULT_TIMEOUT_SECS = 300

create_protagonist_via_tdg

create_protagonist_via_tdg(
    country,
    protagonist_email,
    company_name,
    colleague_count,
)

Open the TDG pre-filled with the protagonist YAML and wait for the user.

Source code in components/clinic/public/commands/setup_steps/test_data_generator.py

@clinic_commands.command()
@click.option(
    "--country",
    type=click.Choice(list(COUNTRIES)),
    default="fr",
    show_default=True,
)
@click.option(
    "--protagonist-email",
    type=str,
    default=lambda: default_protagonist_email(),
    show_default=True,
    help="Email of the protagonist user the TDG will create. Defaults to your AWS IAM identity plus-tagged with `+main.member`.",
)
@click.option(
    "--company-name",
    type=str,
    default="",
    show_default=False,
    help="Demo company to seed for the protagonist. Defaults to `<Local> Co` derived from --protagonist-email (e.g. `Alex Temina Co`).",
)
@click.option(
    "--colleague-count",
    type=int,
    default=DEFAULT_COLLEAGUE_COUNT,
    show_default=True,
    help="Number of additional employees to seed alongside the protagonist.",
)
def create_protagonist_via_tdg(
    country: str, protagonist_email: str, company_name: str, colleague_count: int
) -> None:
    """Open the TDG pre-filled with the protagonist YAML and wait for the user."""
    if not is_development_mode():
        print_error("This command is only available in development mode.")
        return
    if not protagonist_email:
        raise click.UsageError(
            "A protagonist email is required. Pass --protagonist-email or configure AWS credentials."
        )
    step_create_protagonist_via_tdg(
        country=COUNTRIES[country],
        protagonist_email=protagonist_email,
        company_name=company_name,
        colleague_count=colleague_count,
    )

derive_company_name

derive_company_name(protagonist_email)

Derive a demo company name from the protagonist email: <Local Capitalized> Co.

alex.temina+main.member@alan.eu → Alex Temina Co.

Source code in components/clinic/public/commands/setup_steps/test_data_generator.py

def derive_company_name(protagonist_email: str) -> str:
    """Derive a demo company name from the protagonist email: `<Local Capitalized> Co`.

    `alex.temina+main.member@alan.eu` → `Alex Temina Co`.
    """
    local, _ = split_email_local_domain(protagonist_email)
    pretty = " ".join(part.capitalize() for part in local.split(".") if part)
    return f"{pretty} Co"

derive_protagonist_email

derive_protagonist_email(alaner_email)

Derive the protagonist email as <local>+main.member@<domain>.

Source code in components/clinic/public/commands/setup_steps/test_data_generator.py

def derive_protagonist_email(alaner_email: str) -> str:
    """Derive the protagonist email as `<local>+main.member@<domain>`."""
    local, domain = split_email_local_domain(alaner_email)
    return f"{local}+main.member@{domain}"

step_create_protagonist_via_tdg

step_create_protagonist_via_tdg(
    *,
    country,
    protagonist_email,
    company_name="",
    colleague_count=DEFAULT_COLLEAGUE_COUNT,
    timeout_secs=DEFAULT_TIMEOUT_SECS,
    poll_interval_secs=DEFAULT_POLL_INTERVAL_SECS,
    heartbeat_interval_secs=DEFAULT_HEARTBEAT_INTERVAL_SECS
)

Hand off protagonist creation to the TDG and block until the user appears.

Builds the country-specific YAML, opens the TDG editor in the browser pre-filled with it, and then polls the DB until the dev clicks 'Generate' and the User shows up. No-ops silently if the user is already in the DB, so re-running a partial setup doesn't ask you to redo fixtures.

Skipped silently if the country has no tdg_base_url configured. An empty company_name is auto-derived from protagonist_email (Alex Temina Co).

Source code in components/clinic/public/commands/setup_steps/test_data_generator.py

def step_create_protagonist_via_tdg(
    *,
    country: "CountryConfig",
    protagonist_email: str,
    company_name: str = "",
    colleague_count: int = DEFAULT_COLLEAGUE_COUNT,
    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
    poll_interval_secs: int = DEFAULT_POLL_INTERVAL_SECS,
    heartbeat_interval_secs: int = DEFAULT_HEARTBEAT_INTERVAL_SECS,
) -> None:
    """Hand off protagonist creation to the TDG and block until the user appears.

    Builds the country-specific YAML, opens the TDG editor in the browser
    pre-filled with it, and then polls the DB until the dev clicks 'Generate'
    and the `User` shows up. No-ops silently if the user is already in the DB,
    so re-running a partial setup doesn't ask you to redo fixtures.

    Skipped silently if the country has no `tdg_base_url` configured. An empty
    `company_name` is auto-derived from `protagonist_email` (`Alex Temina Co`).
    """
    if not country.tdg_base_url or not country.tdg_protagonist_yaml_template:
        print_info(f"TDG not configured for country={country.name}, skipping.")
        return

    if get_user_by_email(protagonist_email) is not None:
        print_info(
            f"Protagonist user {protagonist_email} already exists, skipping TDG hand-off."
        )
        return

    if not company_name:
        company_name = derive_company_name(protagonist_email)

    yaml_text = country.render_tdg_protagonist_yaml(
        protagonist_email=protagonist_email,
        company_name=company_name,
        colleague_count=colleague_count,
    )
    fixture_b64 = base64.b64encode(yaml_text.encode("utf-8")).decode("ascii")
    url = f"{country.tdg_base_url}/admin_tools/test_data_generator/new?fixture={fixture_b64}"

    opened = open_browser(url)
    print_action(
        "Open the Test Data Generator and click 'Generate':",
        body=[
            url,
            (
                "(Browser opened automatically.)"
                if opened
                else "(Browser unavailable — copy the URL above manually.)"
            ),
        ],
    )

    print_info(f"Waiting for the protagonist user to appear (timeout {timeout_secs}s)…")
    start = time.monotonic()
    deadline = start + timeout_secs
    next_heartbeat = start + heartbeat_interval_secs
    while time.monotonic() < deadline:
        user = get_user_by_email(protagonist_email)
        if user is not None:
            print_success(f"Protagonist user found (id={user.id}).")
            return
        now = time.monotonic()
        if now >= next_heartbeat:
            click.echo(f"  ⏳ {int(now - start)}s elapsed, still waiting…")
            next_heartbeat = now + heartbeat_interval_secs
        time.sleep(poll_interval_secs)

    raise click.ClickException(
        f"Timed out after {timeout_secs}s waiting for protagonist user "
        f"{protagonist_email}. Did the TDG run succeed? Re-run "
        f"`flask clinic create_protagonist_via_tdg` to get a fresh URL."
    )

step_ensure_protagonist_clinic_user

step_ensure_protagonist_clinic_user(*, protagonist_email)

Create the protagonist's ClinicUser if missing, and stamp consent_given_at.

The TDG creates the country User but not the ClinicUser pivot row; without it, none of the clinic-side flows attach to the protagonist.

TODO alex.temina: migrate this to a clinic_user factory in the TDG so the YAML can express - clinic_user: {user: "ref:protagonist", consent_given_at: now} directly, and drop this step. Tracked in the TDG Linear board.

Source code in components/clinic/public/commands/setup_steps/test_data_generator.py

def step_ensure_protagonist_clinic_user(*, protagonist_email: str) -> None:
    """Create the protagonist's `ClinicUser` if missing, and stamp `consent_given_at`.

    The TDG creates the country `User` but not the `ClinicUser` pivot row;
    without it, none of the clinic-side flows attach to the protagonist.

    TODO alex.temina: migrate this to a `clinic_user` factory in the TDG so the YAML can
    express `- clinic_user: {user: "ref:protagonist", consent_given_at: now}`
    directly, and drop this step. Tracked in the TDG Linear board.
    """
    from shared.helpers.db import current_session

    clinic_user = get_or_create_clinic_user_with_consent(protagonist_email)
    current_session.commit()
    print_success(
        f"ClinicUser ready for protagonist (id={clinic_user.id}, consent stamped)."
    )

unread_message_reminders

send_medical_conversations_unread_message_reminders

send_medical_conversations_unread_message_reminders(
    dry_run,
)

Source code in components/clinic/public/commands/unread_message_reminders.py

@clinic_commands.command()
@command_with_dry_run
def send_medical_conversations_unread_message_reminders(dry_run: bool) -> None:  # noqa: D103
    from components.clinic.internal.business_logic.medical_conversation import (
        send_medical_conversations_unread_message_reminders,
    )

    send_medical_conversations_unread_message_reminders(dry_run=dry_run)

user

archive_clinic_user_data

archive_clinic_user_data(clinic_user_id, dry_run)

Archive a clinic user's data to S3 without deleting them.

Runs collect → encrypt → upload → mapping in dry-run mode by default. Pass --execute to perform the actual archive.

Usage

flask clinic archive_clinic_user_data flask clinic archive_clinic_user_data --execute

Source code in components/clinic/public/commands/user.py

@clinic_commands.command()
@click.argument("clinic_user_id", type=UUID)
@command_with_dry_run
def archive_clinic_user_data(clinic_user_id: UUID, dry_run: bool) -> None:
    """Archive a clinic user's data to S3 without deleting them.

    Runs collect → encrypt → upload → mapping in dry-run mode by default.
    Pass --execute to perform the actual archive.

    Usage:
        flask clinic archive_clinic_user_data <clinic_user_id>
        flask clinic archive_clinic_user_data <clinic_user_id> --execute
    """
    from components.clinic.internal.archiving.archiver import archive_clinic_user

    current_logger.info(
        "Archiving clinic user data (no deletion)",
        clinic_user_id=clinic_user_id,
        dry_run=dry_run,
    )
    archive_clinic_user(
        clinic_user_id=clinic_user_id,
        contract_termination_date=None,
        dry_run=dry_run,
    )
    current_logger.info(
        "Done",
        clinic_user_id=clinic_user_id,
        dry_run=dry_run,
    )

clear_stripe_customer_ids

clear_stripe_customer_ids(dry_run)

Clears all stripe_customer_id values from clinic_user table. Only runs in non-production environments. Usage: flask clinic clear_stripe_customer_ids flask clinic clear_stripe_customer_ids --execute

Source code in components/clinic/public/commands/user.py

@clinic_commands.command()
@command_with_dry_run
def clear_stripe_customer_ids(dry_run: bool) -> None:
    # TODO frederic.bonnet 2026-03-23 encapsulate Stripe ID access
    """Clears all stripe_customer_id values from clinic_user table.
    Only runs in non-production environments.
    Usage:
        flask clinic clear_stripe_customer_ids
        flask clinic clear_stripe_customer_ids --execute
    """
    from sqlalchemy import func, select, update

    from components.clinic.internal.models.clinic_user import ClinicUser
    from shared.helpers.db import current_session
    from shared.helpers.env import is_production_mode

    if is_production_mode():
        current_logger.error("Cannot run in production")
        return

    if dry_run:
        count = current_session.execute(
            select(func.count())
            .select_from(ClinicUser)
            # Workspace key: eu_stripe_therapist_booking | ca_stripe_health_services
            .where(ClinicUser.stripe_customer_id.is_not(None))
        ).scalar_one()
        current_logger.info(
            f"DRY RUN - would clear stripe_customer_id for {count} clinic users"
        )
    else:
        result = current_session.execute(
            update(ClinicUser)
            # Workspace key: eu_stripe_therapist_booking | ca_stripe_health_services
            .where(ClinicUser.stripe_customer_id.is_not(None))
            .values(stripe_customer_id=None)
        )
        current_session.commit()
        current_logger.info(
            f"Cleared stripe_customer_id for {result.rowcount} clinic users"
        )

delete_clinic_data_for_user

delete_clinic_data_for_user(clinic_user_id, dry_run)

Delete a clinic user and all associated data for non-medical admin users.

Source code in components/clinic/public/commands/user.py

@clinic_commands.command()
@click.argument("clinic_user_id", type=str)
@command_with_dry_run
def delete_clinic_data_for_user(clinic_user_id: UUID, dry_run: bool) -> None:
    """Delete a clinic user and all associated data for non-medical admin users."""
    from components.clinic.internal.business_logic.clinic_user import (
        delete_all_clinic_data_for_user,
    )

    current_logger.warn(
        "⚠️ This command will delete all clinic user data (conversations, messages, ratings, etc.)"
    )
    delete_all_clinic_data_for_user(clinic_user_id=clinic_user_id, dry_run=dry_run)

inspect_archive

inspect_archive(mapping_filename)

Fetch, decrypt, and print a mapping file and its referenced archive. Dev only.

Usage

flask clinic inspect_archive

Example

flask clinic inspect_archive mapping_clinic-456_20260331_120000.csv.enc

Source code in components/clinic/public/commands/user.py

@clinic_commands.command()
@click.argument("mapping_filename")
def inspect_archive(mapping_filename: str) -> None:
    """Fetch, decrypt, and print a mapping file and its referenced archive. Dev only.

    Usage:
        flask clinic inspect_archive <mapping_filename>

    Example:
        flask clinic inspect_archive mapping_clinic-456_20260331_120000.csv.enc
    """
    import io
    import json

    import defusedcsv.csv as csv

    from components.clinic.internal.archiving.encryption import decrypt_blob
    from shared.helpers.config import current_config
    from shared.helpers.env import is_production_mode
    from shared.services.aws import RemoteFileClient

    if is_production_mode():
        click.echo("ERROR: This command only runs in non-production environments.")
        return

    bucket = current_config.get("CLINIC_ARCHIVAL_S3_BUCKET")
    mapping_key = f"mappings/{mapping_filename}"

    # --- Fetch and decrypt mapping file ---
    click.echo(f"\n=== Mapping file: {mapping_key} ===")
    mapping_buf = io.BytesIO()
    RemoteFileClient.download_from_key_into(mapping_key, mapping_buf, s3_bucket=bucket)
    mapping_csv = decrypt_blob(mapping_buf.read().decode())
    click.echo(mapping_csv.decode())

    # --- Parse the s3_key from the mapping ---
    reader = csv.DictReader(io.StringIO(mapping_csv.decode()))
    rows = list(reader)
    if not rows:
        click.echo("ERROR: Mapping file is empty.")
        return

    s3_key = rows[0]["s3_key"]

    # --- Fetch and decrypt archive file ---
    click.echo(f"=== Archive file: {s3_key} ===")
    archive_buf = io.BytesIO()
    RemoteFileClient.download_from_key_into(s3_key, archive_buf, s3_bucket=bucket)
    archive_data = json.loads(decrypt_blob(archive_buf.read().decode()))
    click.echo(json.dumps(archive_data, indent=2, default=str))

components.clinic.public.dependencies

TherapySessionConfiguration dataclass

TherapySessionConfiguration(
    duration,
    price_multiplier,
    credit_multiplier,
    force_same_length_slot=False,
    available_for_booking=True,
)

Bases: DataClassJsonMixin

Configuration for a therapy session duration variant.

Attributes:

Name	Type	Description
duration	int	Session duration in minutes
price_multiplier	int	Multiplier applied to the base session price
credit_multiplier	int	Multiplier applied to the session credit count
force_same_length_slot	bool	Force google calendar slots to match session duration
available_for_booking	bool	Whether this configuration is visible for booking

available_for_booking class-attribute instance-attribute

available_for_booking = True

credit_multiplier instance-attribute

credit_multiplier

duration instance-attribute

duration

force_same_length_slot class-attribute instance-attribute

force_same_length_slot = False

price_multiplier instance-attribute

price_multiplier

default_session_configurations

default_session_configurations(session_type)

Single-entry default configuration from SESSION_TYPE_CONFIG.

Source code in components/clinic/public/dependencies.py

def default_session_configurations(
    session_type: TherapistBookingSessionType,
) -> list[TherapySessionConfiguration]:
    """Single-entry default configuration from `SESSION_TYPE_CONFIG`."""
    return [
        TherapySessionConfiguration(
            duration=SESSION_TYPE_CONFIG[session_type].session.duration_minutes,
            price_multiplier=1,
            credit_multiplier=1,
        )
    ]

components.clinic.public.entities

app_company

AppCompany dataclass

AppCompany(app_id, app_company_id)

Country-specific company association for an app user (FR/ES/BE/CA).

app_company_id instance-attribute

app_company_id

app_id instance-attribute

app_id

available_health_service

AvailableHealthService dataclass

AvailableHealthService(
    name,
    has_access=None,
    is_recommended=None,
    has_upcoming_availability=None,
)

Bases: DataClassJsonMixin

Available health service available for a clinic user

has_access class-attribute instance-attribute

has_access = None

has_upcoming_availability class-attribute instance-attribute

has_upcoming_availability = None

is_recommended class-attribute instance-attribute

is_recommended = None

name instance-attribute

name

external_onboarding_user

ExternalOnboardingUserData dataclass

ExternalOnboardingUserData(
    email,
    first_name,
    last_name,
    phone_number,
    password,
    prehashed_password,
    gender_str,
    date_of_birth,
    social_security_number,
    place_of_birth_name,
    place_of_birth_postal_code,
    terms_accepted,
    refresh_token_type,
    client_id=None,
    birth_last_name=None,
)

External onboarding user data. Attributes: email: The email of the user. first_name: The first name of the user. last_name: The last name of the user. phone_number: The phone number of the user. password: The password of the user. prehashed_password: The prehashed password of the user. gender_str: The gender of the user. date_of_birth: The date of birth of the user. social_security_number: The social security number of the user. place_of_birth_name: The name of the place of birth of the user. place_of_birth_postal_code: The postal code of the place of birth of the user. terms_accepted: Whether the user has accepted the terms and conditions. refresh_token_type: The refresh token type of the user. client_id: The Keycloak client ID for email verification flow. birth_last_name: The birth last name of the user (maiden name). Defaults to last_name if not provided.

birth_last_name class-attribute instance-attribute

birth_last_name = None

client_id class-attribute instance-attribute

client_id = None

date_of_birth instance-attribute

date_of_birth

email instance-attribute

email

first_name instance-attribute

first_name

gender_str instance-attribute

gender_str

last_name instance-attribute

last_name

password instance-attribute

password

phone_number instance-attribute

phone_number

place_of_birth_name instance-attribute

place_of_birth_name

place_of_birth_postal_code instance-attribute

place_of_birth_postal_code

prehashed_password instance-attribute

prehashed_password

refresh_token_type instance-attribute

refresh_token_type

social_security_number instance-attribute

social_security_number

terms_accepted instance-attribute

terms_accepted

shop_product

ShopProduct dataclass

ShopProduct(id, name, brand, image_url=None)

Bases: DataClassJsonMixin

Shop product visible to health professionals in the catalog.

brand instance-attribute

brand

id instance-attribute

id

image_url class-attribute instance-attribute

image_url = None

name instance-attribute

name

components.clinic.public.enums

available_health_service_name

AvailableHealthServiceName

Bases: AlanBaseEnum

Health services available to members that can be shared to them in the clinic

DATO_CONTENT class-attribute instance-attribute

DATO_CONTENT = 'dato_content'

HEALTH_PROGRAM class-attribute instance-attribute

HEALTH_PROGRAM = 'health_program'

ORIENTATION_CALL class-attribute instance-attribute

ORIENTATION_CALL = 'orientation_call'

SHOP_PRODUCT class-attribute instance-attribute

SHOP_PRODUCT = 'shop_product'

THERAPIST class-attribute instance-attribute

THERAPIST = 'therapist'

THERAPY_SESSION class-attribute instance-attribute

THERAPY_SESSION = 'therapy_session'

VIDEO_CONSULTATION class-attribute instance-attribute

VIDEO_CONSULTATION = 'video_consultation'

VIDEO_CONSULTATION_LIVI class-attribute instance-attribute

VIDEO_CONSULTATION_LIVI = 'video_consultation_livi'

available_shop_product_types

AvailableShopProductTypes

Bases: AlanBaseEnum

Shop products available to HPs that can be shared to members

CONTACT_LENSES class-attribute instance-attribute

CONTACT_LENSES = 'contact_lenses'

pricing

ClinicInvoiceAmountCurrency

Bases: AlanBaseEnum

CAD class-attribute instance-attribute

CAD = 'CAD'

EUR class-attribute instance-attribute

EUR = 'EUR'

GBP class-attribute instance-attribute

GBP = 'GBP'

format_amount

format_amount(amount_in_cents)

Source code in components/clinic/internal/enums/clinic_invoice_amount_currency.py

def format_amount(self, amount_in_cents: int) -> str:
    amount = Decimal(amount_in_cents) / 100
    if self == self.EUR:
        return format_currency(amount, "EUR", locale="fr_FR")
    elif self == self.GBP:
        return format_currency(amount, "GBP", locale="en_GB")
    elif self == self.CAD:
        return format_currency(amount, "CAD", locale="en_CA")
    else:
        raise ValueError(f"Unsupported currency: {self}")

regions

CaAdministrativeAreas

Bases: AlanBaseEnum

Canadian provinces and territories.

Used to specify which administrative regions a medical admin is licensed to operate in. Values use ISO 3166-2:CA codes (CA- prefix + 2-letter region code). -

alberta class-attribute instance-attribute

alberta = 'CA-AB'

british_columbia class-attribute instance-attribute

british_columbia = 'CA-BC'

manitoba class-attribute instance-attribute

manitoba = 'CA-MB'

new_brunswick class-attribute instance-attribute

new_brunswick = 'CA-NB'

newfoundland_and_labrador class-attribute instance-attribute

newfoundland_and_labrador = 'CA-NL'

northwest_territories class-attribute instance-attribute

northwest_territories = 'CA-NT'

nova_scotia class-attribute instance-attribute

nova_scotia = 'CA-NS'

nunavut class-attribute instance-attribute

nunavut = 'CA-NU'

ontario class-attribute instance-attribute

ontario = 'CA-ON'

prince_edward_island class-attribute instance-attribute

prince_edward_island = 'CA-PE'

quebec class-attribute instance-attribute

quebec = 'CA-QC'

saskatchewan class-attribute instance-attribute

saskatchewan = 'CA-SK'

yukon class-attribute instance-attribute

yukon = 'CA-YT'

therapist_booking_session_type

TherapistBookingSessionType

Bases: AlanBaseEnum

Type of booking session supported by the clinic booking experience

consultation class-attribute instance-attribute

consultation = 'consultation'

dermatology class-attribute instance-attribute

dermatology = 'dermatology'

emergency_physiotherapy class-attribute instance-attribute

emergency_physiotherapy = 'emergency_physiotherapy'

orientation class-attribute instance-attribute

orientation = 'orientation'

physiotherapy class-attribute instance-attribute

physiotherapy = 'physiotherapy'

therapy class-attribute instance-attribute

therapy = 'therapy'

components.clinic.public.events

events

ClinicUserDataDeleted dataclass

ClinicUserDataDeleted(user_id, app_id)

Bases: Message

Published after a clinic user and all associated data have been deleted.

Other components should subscribe to clean up their own data linked to this user.

app_id instance-attribute

app_id

user_id instance-attribute

user_id

subscription

subscribe_to_events

subscribe_to_events()

All event subscriptions for the Clinic should be done here.

Source code in components/clinic/public/events/subscription.py

def subscribe_to_events() -> None:
    """
    All event subscriptions for the Clinic should be done here.
    """
    from components.clinic.internal.booking.business_logic.events_subscribers import (
        configure_medical_conversation_when_booking_sessions,
        setup_conversation_for_therapy_session,
        setup_lifecycle_tracking_for_booked_session_from_mo_redirection,
        track_lifecycle_event_for_session_from_mo_redirection,
        trigger_insi_create_or_update_from_id_verification_request,
    )
    from components.clinic.internal.booking.entities.events import (
        SessionCreatedForInternalTeleconsultation,
        SessionCreatedForTherapy,
        SessionRecommendedByMoWasBooked,
        SessionRecommendedByMoWasUpdated,
        TriggerINSiUpdate,
    )
    from components.clinic.internal.business_logic.identity.events_subscribers import (
        update_insi_identity_status_following_id_check,
    )
    from components.id_verification.public.events import (
        IdVerificationValidatedForClinic,
        IdVerificationValidatedForExternalOnboarding,
    )

    message_broker = get_message_broker()
    message_broker.subscribe_async(
        IdVerificationValidatedForClinic,
        update_insi_identity_status_following_id_check,
        queue_name=LOW_PRIORITY_QUEUE,
    )
    message_broker.subscribe_async(
        IdVerificationValidatedForExternalOnboarding,
        update_insi_identity_status_following_id_check,
        queue_name=LOW_PRIORITY_QUEUE,
    )
    message_broker.subscribe_async(
        SessionCreatedForInternalTeleconsultation,
        configure_medical_conversation_when_booking_sessions,
        queue_name=LOW_PRIORITY_QUEUE,
    )
    message_broker.subscribe_async(
        SessionCreatedForTherapy,
        setup_conversation_for_therapy_session,
        queue_name=LOW_PRIORITY_QUEUE,
    )
    message_broker.subscribe_async(
        TriggerINSiUpdate,
        trigger_insi_create_or_update_from_id_verification_request,
        queue_name=LOW_PRIORITY_QUEUE,
    )
    message_broker.subscribe_async(
        SessionRecommendedByMoWasBooked,
        setup_lifecycle_tracking_for_booked_session_from_mo_redirection,
        queue_name=LOW_PRIORITY_QUEUE,
    )
    message_broker.subscribe_async(
        SessionRecommendedByMoWasUpdated,
        track_lifecycle_event_for_session_from_mo_redirection,
        queue_name=LOW_PRIORITY_QUEUE,
    )