69 add endpoints to retrieve from look up data tables

[jcadam14]

Closes #69

Added institutions/address-states, institutions/regulators, and institutions/types/{type} endpoints

Went with a 'generic' InstitutionTypeDTO (since both sbl and hmda tables just have id and name). The /types/ endpoint uses a type Literal to limit the accepted types to sbl or hmda. It then queries the specific Dao type. If this approach isn't desired I can break that GET into two separate types/sbl and types/hmda endpoints that return the specific DTO type.

Updated pytests to test these endpoints and the corresponding get_* functions added to the institution repo.

[github-actions]

Coverage report

The coverage rate went from 86.53% to 87.42% ⬆️
The branch rate is 87%.

100% of new lines are covered.

Diff Coverage details (click to unfold)

src/entities/models/init.py

100% of new lines are covered (100% of the complete file).

src/entities/models/dao.py

100% of new lines are covered (100% of the complete file).

src/entities/models/dto.py

100% of new lines are covered (100% of the complete file).

src/entities/repos/institutions_repo.py

100% of new lines are covered (97.36% of the complete file).

src/entities/repos/repo_utils.py

100% of new lines are covered (100% of the complete file).

src/routers/institutions.py

100% of new lines are covered (99.16% of the complete file).

[lchen-2101]

let's abstract this portion out, since it's repeated across all of the lookups

[lchen-2101]

or better yet, just have something like get_look_up(session..., T) -> List[T] or something like that

[jcadam14]

Added a repo_utiils with the following

from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from typing import List, TypeVar

T = TypeVar("T")


async def query_type(session: AsyncSession, type: T) -> List[T]:
    async with session.begin():
        stmt = select(type)
        res = await session.scalars(stmt)
        return res.all()

I thought about putting that directly in the institution_repo and having the routers call it, but as it stands the routers don't "know" about DAOs, just DTOs, so I kept it separate. And the institution_repo now has:

async def get_sbl_types(session: AsyncSession) -> List[SBLInstitutionTypeDao]:
    return await query_type(session, SBLInstitutionTypeDao)


async def get_hmda_types(session: AsyncSession) -> List[HMDAInstitutionTypeDao]:
    return await query_type(session, HMDAInstitutionTypeDao)


async def get_address_states(session: AsyncSession) -> List[AddressStateDao]:
    return await query_type(session, AddressStateDao)


async def get_federal_regulators(session: AsyncSession) -> List[FederalRegulatorDao]:
    return await query_type(session, FederalRegulatorDao)

which again is somewhat repetitive, but less so than before.

[lchen-2101]

The return type should be a collection, shouldn't it?

[jcadam14]

Yup, updated all these funcs to return List[type]

[lchen-2101]

let's be explicit with hmda as well, and throw invalid arg exception when neither matches

[lchen-2101]

oh I see, the Literal would take care of that, in that case I'd still like hmda to be explicit, so maybe use match

[jcadam14]

Changed to

    match type:
        case "sbl":
            return await repo.get_sbl_types(request.state.db_session)
        case "hmda":
            return await repo.get_hmda_types(request.state.db_session)

[lchen-2101]

now looking at it, just one dto would work for both, so we can completely remove the distinct ones, at least until the need arises when differences come up later. we can probably also update the dao to have one base dao, and the two specific ones inherit from that, and only change the __tablename__

[jcadam14]

Removed commented out DTO references. Added a InstitutionTypeMixin that the HMDA and SBL Inst. Types inherit. Couldn't see a cleaner way to add inheritance here.

[lchen-2101]

LGTM