Solved the merge conflicts and modified the related tests.

Author: EstelleDa

Dockerfile

@@ -2,7 +2,7 @@
 # python-base
 # Set up shared environment variables
 ################################
-FROM --platform=amd64 python:3.11 AS python-base
+FROM python:3.11 AS python-base
 
     # Poetry
     # https://python-poetry.org/docs/configuration/#using-environment-variables

alembic/manual_migrations/migrate_consolidated_score_ranges_and_calibrations.py

@@ -9,7 +9,7 @@
 from sqlalchemy.orm import Session
 
 from mavedb.models.score_set import ScoreSet
-from mavedb.view_models.score_range import ScoreSetRangesCreate, InvestigatorScoreRangesCreate, PillarProjectScoreRangesCreate, PillarProjectScoreRangeCreate
+from mavedb.view_models.score_range import ScoreSetRangesCreate, InvestigatorScoreRangesCreate, ZeibergCalibrationScoreRangesCreate, ZeibergCalibrationScoreRangeCreate
 
 
 from mavedb.db.session import SessionLocal
@@ -47,11 +47,11 @@ def do_migration(db: Session):
             investigator_ranges = None
 
         if score_set.score_calibrations is not None:
-            thresholds = score_set.score_calibrations.get("pillar_project", {}).get("thresholds", [])
-            evidence_strengths = score_set.score_calibrations.get("pillar_project", {}).get("evidence_strengths", [])
-            positive_likelihood_ratios = score_set.score_calibrations.get("pillar_project", {}).get("positive_likelihood_ratios", [])
-            prior_probability_pathogenicity = score_set.score_calibrations.get("pillar_project", {}).get("prior_probability_pathogenicity", None)
-            parameter_sets = score_set.score_calibrations.get("pillar_project", {}).get("parameter_sets", [])
+            thresholds = score_set.score_calibrations.get("zeiberg_calibration", {}).get("thresholds", [])
+            evidence_strengths = score_set.score_calibrations.get("zeiberg_calibration", {}).get("evidence_strengths", [])
+            positive_likelihood_ratios = score_set.score_calibrations.get("zeiberg_calibration", {}).get("positive_likelihood_ratios", [])
+            prior_probability_pathogenicity = score_set.score_calibrations.get("zeiberg_calibration", {}).get("prior_probability_pathogenicity", None)
+            parameter_sets = score_set.score_calibrations.get("zeiberg_calibration", {}).get("parameter_sets", [])
 
             ranges = []
             boundary_direction = -1  # Start with a negative sign to indicate the first range has the lower boundary appearing prior to the threshold
@@ -60,7 +60,7 @@ def do_migration(db: Session):
 
                 if idx == 0:
                     calculated_range = (None, threshold)
-                    ranges.append(PillarProjectScoreRangeCreate(
+                    ranges.append(ZeibergCalibrationScoreRangeCreate(
                         range=(None, threshold),
                         classification="normal" if evidence_strength < 0 else "abnormal",
                         label=str(evidence_strength),
@@ -71,7 +71,7 @@ def do_migration(db: Session):
                     ))
                 elif idx == len(thresholds) - 1:
                     calculated_range = (threshold, None)
-                    ranges.append(PillarProjectScoreRangeCreate(
+                    ranges.append(ZeibergCalibrationScoreRangeCreate(
                         range=(threshold, None),
                         classification="normal" if evidence_strength < 0 else "abnormal",
                         evidence_strength=evidence_strength,
@@ -86,7 +86,7 @@ def do_migration(db: Session):
                     else:
                         calculated_range = (threshold, thresholds[idx + 1])
 
-                    ranges.append(PillarProjectScoreRangeCreate(
+                    ranges.append(ZeibergCalibrationScoreRangeCreate(
                         range=calculated_range,
                         classification="normal" if evidence_strength < 0 else "abnormal",
                         label=str(evidence_strength),
@@ -100,17 +100,17 @@ def do_migration(db: Session):
                 if idx != len(evidence_strengths) - 1 and (evidence_strengths[idx + 1] * evidence_strength < 0):
                     boundary_direction = -boundary_direction
 
-                pillar_project_ranges = PillarProjectScoreRangesCreate(
+                zeiberg_calibration_ranges = ZeibergCalibrationScoreRangesCreate(
                     prior_probability_pathogenicity=prior_probability_pathogenicity,
                     parameter_sets=parameter_sets,
                     ranges=ranges,
                 )
         else:
-            pillar_project_ranges = None
+            zeiberg_calibration_ranges = None
 
         score_set.score_ranges = ScoreSetRangesCreate(
             investigator_provided=investigator_ranges if investigator_ranges else None,
-            pillar_project=pillar_project_ranges if pillar_project_ranges else None,
+            zeiberg_calibration=zeiberg_calibration_ranges if zeiberg_calibration_ranges else None,
         ).model_dump()
         db.add(score_set)
 

docker-compose-dev.yml

@@ -48,6 +48,7 @@ services:
       - redis
 
   dcd-mapping:
+    build: ../dcd_mapping
     image: dcd-mapping:dev
     command: bash -c "uvicorn api.server_main:app --host 0.0.0.0 --port 8000 --reload"
     depends_on:
@@ -61,14 +62,18 @@ services:
       - mavedb-seqrepo-dev:/usr/local/share/seqrepo
 
   cdot-rest:
+    build: ../cdot_rest
     image: cdot-rest:dev
     command: bash -c "gunicorn cdot_rest.wsgi:application --bind 0.0.0.0:8000"
     env_file:
       - settings/.env.dev
     depends_on:
       - redis
+      - seqrepo
     ports:
       - "8006:8000"
+    volumes:
+      - mavedb-seqrepo-dev:/usr/local/share/seqrepo
 
   db:
     image: postgres:14

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mavedb"
-version = "2025.3.0"
+version = "2025.4.1"
 description = "API for MaveDB, the database of Multiplexed Assays of Variant Effect."
 license = "AGPL-3.0-only"
 readme = "README.md"

settings/.env.template

@@ -67,8 +67,10 @@ DCD_MAPPING_URL=http://dcd-mapping:8000
 ####################################################################################################
 
 CDOT_URL=http://cdot-rest:8000
-REDIS_HOST=localhost
+REDIS_HOST=redis
+REDIS_IP=redis
 REDIS_PORT=6379
+REDIS_SSL=false
 
 ####################################################################################################
 # Environment variables for ClinGen

src/mavedb/__init__.py

@@ -6,6 +6,6 @@
 logger = module_logging.getLogger(__name__)
 
 __project__ = "mavedb-api"
-__version__ = "2025.3.0"
+__version__ = "2025.4.1"
 
 logger.info(f"MaveDB {__version__}")

src/mavedb/db/view.py

@@ -6,8 +6,8 @@
 
 import sqlalchemy as sa
 from sqlalchemy.ext import compiler
-from sqlalchemy.schema import DDLElement, MetaData
 from sqlalchemy.orm import Session
+from sqlalchemy.schema import DDLElement, MetaData
 
 from mavedb.db.base import Base
 
@@ -32,7 +32,53 @@ class MaterializedView(Base):
 
     @classmethod
     def refresh(cls, connection, concurrently=True):
-        """Refresh this materialized view."""
+        """
+        Refresh the underlying materialized view for this ORM-mapped class.
+
+        This class method delegates to `refresh_mat_view` to issue a database
+        REFRESH MATERIALIZED VIEW (optionally CONCURRENTLY) statement for the
+        materialized view backing the current model (`cls.__table__.fullname`).
+
+        Parameters
+        ---------
+        connection : sqlalchemy.engine.Connection | sqlalchemy.orm.Session
+            An active SQLAlchemy connection or session bound to the target database.
+        concurrently : bool, default True
+            If True, performs a concurrent refresh (REFRESH MATERIALIZED VIEW CONCURRENTLY),
+            allowing reads during the refresh when the database backend supports it.
+            If False, performs a blocking refresh.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        sqlalchemy.exc.DBAPIError
+            If the database reports an error while refreshing the materialized view.
+        sqlalchemy.exc.OperationalError
+            For operational issues such as locks or insufficient privileges.
+        ValueError
+            If the connection provided is not a valid SQLAlchemy connection/session.
+
+        Notes
+        -----
+        - A concurrent refresh typically requires the materialized view to have a unique
+          index matching all rows; otherwise the database may reject the operation.
+        - This operation does not return a value; it is executed for its side effect.
+        - Ensure the connection/session is in a clean transactional state if you rely on
+          consistent snapshot semantics.
+        - This function commits no changes; it is the caller's responsibility to
+          commit the session if needed.
+
+        Examples
+        --------
+        # Refresh with concurrent mode (default)
+        MyMaterializedView.refresh(connection)
+
+        # Perform a blocking refresh
+        MyMaterializedView.refresh(connection, concurrently=False)
+        """
         refresh_mat_view(connection, cls.__table__.fullname, concurrently)
 
 
@@ -123,19 +169,91 @@ class MyView(Base):
 
 def refresh_mat_view(session: Session, name: str, concurrently=True):
     """
-    Refreshes a single materialized view, given by `name`.
+    Refresh a PostgreSQL materialized view within the current SQLAlchemy session.
+
+    This helper issues a REFRESH MATERIALIZED VIEW statement for the specified
+    materialized view name. It first explicitly flushes the session because
+    session.execute() bypasses SQLAlchemy's autoflush mechanism; without the flush,
+    pending changes (e.g., newly inserted/updated rows that the view depends on)
+    might not be reflected in the refreshed view.
+
+    Parameters
+    ----------
+    session : sqlalchemy.orm.Session
+        An active SQLAlchemy session bound to a PostgreSQL database.
+    name : str
+        The exact name (optionally schema-qualified) of the materialized view to refresh.
+    concurrently : bool, default True
+        If True, uses REFRESH MATERIALIZED VIEW CONCURRENTLY allowing reads during
+        the refresh and requiring a unique index on the materialized view. If False,
+        performs a blocking refresh.
+
+    Raises
+    ------
+    sqlalchemy.exc.SQLAlchemyError
+        Propagates any database errors encountered during execution (e.g.,
+        insufficient privileges, missing view, lack of required unique index for
+        CONCURRENTLY).
+
+    Notes
+    -----
+    - Using CONCURRENTLY requires the materialized view to have at least one
+      unique index; otherwise PostgreSQL will raise an error.
+    - The operation does not return a value; it is executed for its side effect.
+    - Ensure the session is in a clean transactional state if you rely on
+      consistent snapshot semantics.
+    - This function commits no changes; it is the caller's responsibility to
+      commit the session if needed.
+
+    Examples
+    --------
+    refresh_mat_view(session, "public.my_materialized_view")
+    refresh_mat_view(session, "reports.daily_stats", concurrently=False)
     """
     # since session.execute() bypasses autoflush, must manually flush in order
     # to include newly-created/modified objects in the refresh
     session.flush()
+
     _con = "CONCURRENTLY " if concurrently else ""
     session.execute(sa.text("REFRESH MATERIALIZED VIEW " + _con + name))
 
 
 def refresh_all_mat_views(session: Session, concurrently=True):
     """
-    Refreshes all materialized views. Views are refreshed in non-deterministic order,
-    so view definitions can't depend on each other.
+    Refreshes all PostgreSQL materialized views visible to the given SQLAlchemy session.
+
+    The function inspects the current database connection for registered materialized
+    views and issues a REFRESH MATERIALIZED VIEW command for each one using the helper
+    function `refresh_mat_view`. After all refresh operations complete, the session
+    is committed to persist any transactional side effects of the refresh statements.
+
+    Parameters
+    ----------
+    session : sqlalchemy.orm.Session
+        An active SQLAlchemy session bound to a PostgreSQL connection.
+    concurrently : bool, default True
+        If True, each materialized view is refreshed using the CONCURRENTLY option
+        (only supported when the view has a unique index that satisfies PostgreSQL
+        requirements). If False, a standard blocking refresh is performed.
+
+    Behavior
+    --------
+    - If inspection of the connection fails or returns no inspector, the function
+      exits without performing any work.
+    - Each materialized view name returned by the inspector is passed to
+      `refresh_mat_view(session, name, concurrently)`.
+
+    Notes
+    -----
+    - Using CONCURRENTLY allows reads during refresh at the cost of requiring an
+      appropriate unique index and potentially being slower.
+    - Exceptions raised during individual refresh operations will propagate unless
+      `refresh_mat_view` handles them internally; in such a case the commit will
+      not be reached.
+    - Ensure the session is in a clean transactional state if you rely on
+      consistent snapshot semantics.
+    - This function commits no changes; it is the caller's responsibility to
+      commit the session if needed.
     """
     inspector = sa.inspect(session.connection())
 

src/mavedb/lib/annotation/agent.py

@@ -58,14 +58,14 @@ def mavedb_user_agent(user: User) -> Agent:
 
 
 # XXX: Ideally, this becomes versioned software.
-def pillar_project_calibration_agent() -> Agent:
+def zeiberg_calibration_agent() -> Agent:
     """
     Create a [VA Agent](https://va-ga4gh.readthedocs.io/en/latest/core-information-model/entities/agent.html)
-    object for the pillar project calibration software.
+    object for the Zeiberg calibration software.
     """
     return Agent(
-        name="Pillar Project Variant Calibrator",
+        name="Zeiberg Variant Calibrator",
         agentType="Software",
         # XXX - version?
-        description="Pillar project variant calibrator, see https://github.com/Dzeiberg/mave_calibration",
+        description="Zeiberg variant calibrator, see https://github.com/Dzeiberg/mave_calibration",
     )

src/mavedb/lib/annotation/classification.py

@@ -6,7 +6,7 @@
 from ga4gh.va_spec.base.enums import StrengthOfEvidenceProvided
 
 from mavedb.models.mapped_variant import MappedVariant
-from mavedb.lib.annotation.constants import PILLAR_PROJECT_CALIBRATION_STRENGTH_OF_EVIDENCE_MAP
+from mavedb.lib.annotation.constants import ZEIBERG_CALIBRATION_CALIBRATION_STRENGTH_OF_EVIDENCE_MAP
 from mavedb.lib.validation.utilities import inf_or_float
 from mavedb.view_models.score_range import ScoreSetRanges
 
@@ -33,7 +33,7 @@ def functional_classification_of_variant(
     # This view model object is much simpler to work with.
     score_ranges = ScoreSetRanges(**mapped_variant.variant.score_set.score_ranges).investigator_provided
 
-    if not score_ranges:
+    if not score_ranges or not score_ranges.ranges:
         raise ValueError(
             f"Variant {mapped_variant.variant.urn} does not have investigator-provided score ranges."
             " Unable to classify functional impact."
@@ -60,7 +60,7 @@ def functional_classification_of_variant(
     return ExperimentalVariantFunctionalImpactClassification.INDETERMINATE
 
 
-def pillar_project_clinical_classification_of_variant(
+def zeiberg_calibration_clinical_classification_of_variant(
     mapped_variant: MappedVariant,
 ) -> tuple[VariantPathogenicityEvidenceLine.Criterion, Optional[StrengthOfEvidenceProvided]]:
     if mapped_variant.variant.score_set.score_ranges is None:
@@ -69,9 +69,9 @@ def pillar_project_clinical_classification_of_variant(
             " Unable to classify clinical impact."
         )
 
-    score_ranges = ScoreSetRanges(**mapped_variant.variant.score_set.score_ranges).pillar_project
+    score_ranges = ScoreSetRanges(**mapped_variant.variant.score_set.score_ranges).zeiberg_calibration
 
-    if not score_ranges:
+    if not score_ranges or not score_ranges.ranges:
         raise ValueError(
             f"Variant {mapped_variant.variant.urn} does not have pillar project score ranges."
             " Unable to classify clinical impact."
@@ -88,6 +88,6 @@ def pillar_project_clinical_classification_of_variant(
     for range in score_ranges.ranges:
         lower_bound, upper_bound = inf_or_float(range.range[0], lower=True), inf_or_float(range.range[1], lower=False)
         if functional_score > lower_bound and functional_score <= upper_bound:
-            return PILLAR_PROJECT_CALIBRATION_STRENGTH_OF_EVIDENCE_MAP[range.evidence_strength]
+            return ZEIBERG_CALIBRATION_CALIBRATION_STRENGTH_OF_EVIDENCE_MAP[range.evidence_strength]
 
-    return PILLAR_PROJECT_CALIBRATION_STRENGTH_OF_EVIDENCE_MAP[0]
+    return ZEIBERG_CALIBRATION_CALIBRATION_STRENGTH_OF_EVIDENCE_MAP[0]

src/mavedb/lib/annotation/constants.py

@@ -4,7 +4,7 @@
 GENERIC_DISEASE_MEDGEN_CODE = "C0012634"
 MEDGEN_SYSTEM = "https://www.ncbi.nlm.nih.gov/medgen/"
 
-PILLAR_PROJECT_CALIBRATION_STRENGTH_OF_EVIDENCE_MAP = {
+ZEIBERG_CALIBRATION_CALIBRATION_STRENGTH_OF_EVIDENCE_MAP = {
     # No evidence
     0: (VariantPathogenicityEvidenceLine.Criterion.PS3, None),
     # Supporting evidence
@@ -31,4 +31,4 @@
 
 # TODO#493
 FUNCTIONAL_RANGES = ["investigator_provided"]
-CLINICAL_RANGES = ["pillar_project"]
+CLINICAL_RANGES = ["zeiberg_calibration"]