Merge branch 'main' into annotator-side-effect

.github/workflows/release.yml

@@ -16,7 +16,7 @@ jobs:
         id: get_branch_name
         run: |
           raw=$(git branch -r --contains ${{ github.ref }})
-          branch=$(echo "$raw" | grep "origin/main" | sed "s|origin/||" | xargs)
+          branch=$(echo "$raw" | grep "origin/main" | grep -v "HEAD" | sed "s|origin/||" | xargs)
           echo "name=$branch" >> "$GITHUB_OUTPUT"
   build:
     name: Build distribution

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "submodules/vrs"]
 	path = submodules/vrs
 	url = https://github.com/ga4gh/vrs.git
-	branch = 2.0.0-ballot.2024-11
+	branch = 2.0.0-snapshot.2025-02

src/ga4gh/core/models.py

@@ -18,6 +18,12 @@
 from ga4gh.core.identifiers import GA4GH_IR_REGEXP
 
 
+class BaseModelForbidExtra(BaseModel):
+    """Base Pydantic model class with extra attributes forbidden."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
 class Relation(str, Enum):
     """A mapping relation between concepts as defined by the Simple Knowledge
     Organization System (SKOS).
@@ -95,11 +101,11 @@ class Entity(BaseModel, ABC):
         ...,
         description="The name of the class that is instantiated by a data object representing the Entity.",
     )
-    label: Optional[str] = Field(None, description="A primary name for the entity.")
+    name: Optional[str] = Field(None, description="A primary name for the entity.")
     description: Optional[str] = Field(
         None, description="A free-text description of the Entity."
     )
-    alternativeLabels: Optional[list[str]] = Field(  # noqa: N815
+    aliases: Optional[list[str]] = Field(
         None, description="Alternative name(s) for the Entity."
     )
     extensions: Optional[list[Extension]] = Field(
@@ -129,12 +135,12 @@ class Element(BaseModel, ABC):
 #########################################
 
 
-class Coding(Element):
+class Coding(Element, BaseModelForbidExtra):
     """A structured representation of a code for a defined concept in a terminology or
     code system.
     """
 
-    label: Optional[str] = Field(
+    name: Optional[str] = Field(
         None,
         description="The human-readable name for the coded concept, as defined by the code system.",
     )
@@ -149,7 +155,7 @@ class Coding(Element):
     code: code  # Cannot use Field due to PydanticUserError: field name and type annotation must not clash.
 
 
-class ConceptMapping(Element):
+class ConceptMapping(Element, BaseModelForbidExtra):
     """A mapping to a concept in a terminology or code system."""
 
     model_config = ConfigDict(use_enum_values=True)
@@ -164,7 +170,7 @@ class ConceptMapping(Element):
     )
 
 
-class Extension(Element):
+class Extension(Element, BaseModelForbidExtra):
     """The Extension class provides entities with a means to include additional
     attributes that are outside of the specified standard but needed by a given content
     provider or system implementer. These extensions are not expected to be natively
@@ -186,14 +192,14 @@ class Extension(Element):
     )
 
 
-class MappableConcept(Element):
-    """A concept label that may be mapped to one or more `Codings`."""
+class MappableConcept(Element, BaseModelForbidExtra):
+    """A concept name that may be mapped to one or more `Codings`."""
 
     conceptType: Optional[str] = Field(  # noqa: N815
         None,
         description="A term indicating the type of concept being represented by the MappableConcept.",
     )
-    label: Optional[str] = Field(None, description="A primary name for the concept.")
+    name: Optional[str] = Field(None, description="A primary name for the concept.")
     primaryCode: Optional[code] = Field(  # noqa: N815
         None,
         description="A primary code for the concept that is used to identify the concept in a terminology or code system. If there is a public code system for the primaryCode then it should also be specified in the mappings array with a relation of 'exactMatch'. This attribute is provided to both allow a more technical code to be used when a public Coding with a system is not available as well as when it is available but should be identified as the primary code.",
@@ -203,11 +209,16 @@ class MappableConcept(Element):
         description="A list of mappings to concepts in terminologies or code systems. Each mapping should include a coding and a relation.",
     )
 
+    class ga4gh:  # noqa: N801
+        """Contain properties used for computing digests"""
+
+        inherent: tuple[str] = ("primaryCode",)
+
     @model_validator(mode="after")
-    def require_label_or_primary_code(cls, v):  # noqa: ANN001 N805 ANN201
-        """Ensure that ``label`` or ``primaryCode`` is provided"""
-        if v.primaryCode is None and v.label is None:
-            err_msg = "`One of label` or `primaryCode` must be provided."
+    def require_name_or_primary_code(cls, v):  # noqa: ANN001 N805 ANN201
+        """Ensure that ``name`` or ``primaryCode`` is provided"""
+        if v.primaryCode is None and v.name is None:
+            err_msg = "`One of name` or `primaryCode` must be provided."
             raise ValueError(err_msg)
         return v
 

src/ga4gh/vrs/models.py

@@ -37,7 +37,13 @@
     PrevVrsVersion,
     sha512t24u,
 )
-from ga4gh.core.models import Element, Entity, MappableConcept, iriReference
+from ga4gh.core.models import (
+    BaseModelForbidExtra,
+    Element,
+    Entity,
+    MappableConcept,
+    iriReference,
+)
 from ga4gh.core.pydantic import get_pydantic_root, getattr_in
 
 
@@ -137,12 +143,12 @@ def pydantic_class_refatt_map():
                 class_reffable_fields.append(fieldname)
         if len(class_reffable_fields) > 0:
             reffable_fields[model_class.__name__] = class_reffable_fields
-    class_keys = {}
+    class_inherent = {}
     for model_class in model_classes:
-        keys = getattr_in(model_class, ["ga4gh", "keys"])
-        if keys and len(keys) > 0:
-            class_keys[model_class.__name__] = keys
-    return (reffable_classes, union_reffable_classes, reffable_fields, class_keys)
+        inherent = getattr_in(model_class, ["ga4gh", "inherent"])
+        if inherent and len(inherent) > 0:
+            class_inherent[model_class.__name__] = inherent
+    return (reffable_classes, union_reffable_classes, reffable_fields, class_inherent)
 
 
 class VrsType(str, Enum):
@@ -242,13 +248,13 @@ def __hash__(self):
 
     def ga4gh_serialize(self) -> Dict:
         out = OrderedDict()
-        for k in self.ga4gh.keys:
+        for k in self.ga4gh.inherent:
             v = getattr(self, k)
             out[k] = _recurse_ga4gh_serialize(v)
         return out
 
     class ga4gh:  # noqa: N801
-        keys: List[str]
+        inherent: List[str]
 
     @staticmethod
     def is_ga4gh_identifiable() -> bool:
@@ -369,7 +375,7 @@ class ga4gh(_ValueObject.ga4gh):  # noqa: N801
         prefix: str
 
 
-class Expression(Element):
+class Expression(Element, BaseModelForbidExtra):
     """Representation of a variation by a specified nomenclature or syntax for a
     Variation object. Common examples of expressions for the description of molecular
     variation include the HGVS and ISCN nomenclatures.
@@ -465,7 +471,7 @@ class sequenceString(RootModel):
 #########################################
 
 
-class LengthExpression(_ValueObject):
+class LengthExpression(_ValueObject, BaseModelForbidExtra):
     """A sequence expressed only by its length."""
 
     type: Literal["LengthExpression"] = Field(
@@ -476,10 +482,10 @@ class LengthExpression(_ValueObject):
     )
 
     class ga4gh(_ValueObject.ga4gh):
-        keys = ["length", "type"]
+        inherent = ["length", "type"]
 
 
-class ReferenceLengthExpression(_ValueObject):
+class ReferenceLengthExpression(_ValueObject, BaseModelForbidExtra):
     """An expression of a length of a sequence from a repeating reference."""
 
     type: Literal["ReferenceLengthExpression"] = Field(
@@ -498,10 +504,10 @@ class ReferenceLengthExpression(_ValueObject):
     )
 
     class ga4gh(_ValueObject.ga4gh):
-        keys = ["length", "repeatSubunitLength", "type"]
+        inherent = ["length", "repeatSubunitLength", "type"]
 
 
-class LiteralSequenceExpression(_ValueObject):
+class LiteralSequenceExpression(_ValueObject, BaseModelForbidExtra):
     """An explicit expression of a Sequence."""
 
     type: Literal["LiteralSequenceExpression"] = Field(
@@ -511,15 +517,15 @@ class LiteralSequenceExpression(_ValueObject):
     sequence: sequenceString = Field(..., description="the literal sequence")
 
     class ga4gh(_ValueObject.ga4gh):
-        keys = ["sequence", "type"]
+        inherent = ["sequence", "type"]
 
 
 #########################################
 # vrs location
 #########################################
 
 
-class SequenceReference(_ValueObject):
+class SequenceReference(_ValueObject, BaseModelForbidExtra):
     """A sequence of nucleic or amino acid character codes."""
 
     model_config = ConfigDict(use_enum_values=True)
@@ -551,25 +557,26 @@ class SequenceReference(_ValueObject):
     )
 
     class ga4gh(_ValueObject.ga4gh):
-        keys = ["refgetAccession", "type"]
+        inherent = ["refgetAccession", "type"]
 
 
-class SequenceLocation(Ga4ghIdentifiableObject):
-    """A `Location` defined by an interval on a referenced `Sequence`."""
+class SequenceLocation(Ga4ghIdentifiableObject, BaseModelForbidExtra):
+    """A `Location` defined by an interval on a `Sequence`."""
 
     type: Literal["SequenceLocation"] = Field(
         VrsType.SEQ_LOC.value, description=f'MUST be "{VrsType.SEQ_LOC.value}"'
     )
     sequenceReference: Optional[Union[iriReference, SequenceReference]] = Field(
-        None, description="A reference to a Sequence on which the location is defined."
+        None,
+        description="A reference to a SequenceReference on which the location is defined.",
     )
     start: Optional[Union[Range, int]] = Field(
         None,
-        description="The start coordinate or range of the SequenceLocation. The minimum value of this coordinate or range is 0. For locations on linear sequences, this MUST represent a coordinate or range  less than or equal to the value of `end`. For circular sequences, `start` is greater than `end` when the location spans the sequence 0 coordinate.",
+        description="The start coordinate or range of the SequenceLocation. The minimum value of this coordinate or range is 0. For locations on linear sequences, this MUST represent a coordinate or range less than or equal to the value of `end`. For circular sequences, `start` is greater than `end` when the location spans the sequence 0 coordinate.",
     )
     end: Optional[Union[Range, int]] = Field(
         None,
-        description="The end coordinate or range of the SequenceLocation. The minimum value of this coordinate or range is 0. For locations on linear sequences, this MUST represent a coordinate or range  grater than or equal to the value of `start`. For circular sequences, `end` is less than `start` when the location spans the sequence 0 coordinate.",
+        description="The end coordinate or range of the SequenceLocation. The minimum value of this coordinate or range is 0. For locations on linear sequences, this MUST represent a coordinate or range greater than or equal to the value of `start`. For circular sequences, `end` is less than `start` when the location spans the sequence 0 coordinate.",
     )
     sequence: Optional[sequenceString] = Field(
         None,
@@ -640,7 +647,7 @@ def get_refget_accession(self):
     class ga4gh(Ga4ghIdentifiableObject.ga4gh):  # noqa: N801
         prefix = "SL"
         priorPrefix = {PrevVrsVersion.V1_3.value: "VSL"}  # noqa: N815
-        keys = ["end", "sequenceReference", "start", "type"]
+        inherent = ["end", "sequenceReference", "start", "type"]
 
 
 #########################################
@@ -659,7 +666,7 @@ class _VariationBase(Ga4ghIdentifiableObject, ABC):
 #########################################
 
 
-class Allele(_VariationBase):
+class Allele(_VariationBase, BaseModelForbidExtra):
     """The state of a molecule at a `Location`."""
 
     type: Literal["Allele"] = Field(
@@ -700,10 +707,10 @@ def ga4gh_serialize_as_version(self, as_version: PrevVrsVersion):
     class ga4gh(Ga4ghIdentifiableObject.ga4gh):  # noqa: N801
         prefix = "VA"
         priorPrefix = {PrevVrsVersion.V1_3.value: "VA"}  # noqa: N815
-        keys = ["location", "state", "type"]
+        inherent = ["location", "state", "type"]
 
 
-class CisPhasedBlock(_VariationBase):
+class CisPhasedBlock(_VariationBase, BaseModelForbidExtra):
     """An ordered set of co-occurring `Variation` on the same molecule."""
 
     type: Literal["CisPhasedBlock"] = Field(
@@ -727,15 +734,15 @@ def ga4gh_serialize(self) -> Dict:
 
     class ga4gh(Ga4ghIdentifiableObject.ga4gh):
         prefix = "CPB"
-        keys = ["members", "type"]
+        inherent = ["members", "type"]
 
 
 #########################################
 # vrs structural variation (under active discussion)
 #########################################
 
 
-class Adjacency(_VariationBase):
+class Adjacency(_VariationBase, BaseModelForbidExtra):
     """The `Adjacency` class represents the adjoining of the end of a sequence with the
     beginning of an adjacent sequence, potentially with an intervening linker sequence.
     """
@@ -775,10 +782,10 @@ def validate_adjoined_sequences(
 
     class ga4gh(Ga4ghIdentifiableObject.ga4gh):
         prefix = "AJ"
-        keys = ["adjoinedSequences", "linker", "type"]
+        inherent = ["adjoinedSequences", "linker", "type"]
 
 
-class Terminus(_VariationBase):
+class Terminus(_VariationBase, BaseModelForbidExtra):
     """The `Terminus` data class provides a structure for describing the end
     (terminus) of a sequence. Structurally similar to Adjacency but the linker sequence
     is not allowed and it removes the unnecessary array structure.
@@ -793,10 +800,10 @@ class Terminus(_VariationBase):
 
     class ga4gh(Ga4ghIdentifiableObject.ga4gh):  # noqa: N815
         prefix = "TM"
-        keys = ["location", "type"]
+        inherent = ["location", "type"]
 
 
-class TraversalBlock(_ValueObject):
+class TraversalBlock(_ValueObject, BaseModelForbidExtra):
     """A component used to describe the orientation of applicable molecular variation
     within a DerivativeMolecule.
     """
@@ -816,10 +823,10 @@ class TraversalBlock(_ValueObject):
     )
 
     class ga4gh(_ValueObject.ga4gh):
-        keys = ["component", "orientation", "type"]
+        inherent = ["component", "orientation", "type"]
 
 
-class DerivativeMolecule(_VariationBase):
+class DerivativeMolecule(_VariationBase, BaseModelForbidExtra):
     """The "Derivative Molecule" data class is a structure for describing a derivate
     molecule composed from multiple sequence components.
     """
@@ -842,15 +849,15 @@ class DerivativeMolecule(_VariationBase):
 
     class ga4gh(Ga4ghIdentifiableObject.ga4gh):  # noqa: N815
         prefix = "DM"
-        keys = ["components", "type"]
+        inherent = ["components", "type"]
 
 
 #########################################
 # vrs systemic variation
 #########################################
 
 
-class CopyNumberCount(_VariationBase):
+class CopyNumberCount(_VariationBase, BaseModelForbidExtra):
     """The absolute count of discrete copies of a `Location`, within a system
     (e.g. genome, cell, etc.).
     """
@@ -868,10 +875,10 @@ class CopyNumberCount(_VariationBase):
 
     class ga4gh(Ga4ghIdentifiableObject.ga4gh):  # noqa: N815
         prefix = "CN"
-        keys = ["copies", "location", "type"]
+        inherent = ["copies", "location", "type"]
 
 
-class CopyNumberChange(_VariationBase):
+class CopyNumberChange(_VariationBase, BaseModelForbidExtra):
     """An assessment of the copy number of a `Location` within a system
     (e.g. genome, cell, etc.) relative to a baseline ploidy.
     """
@@ -912,7 +919,7 @@ def validate_copy_change(cls, v) -> MappableConcept:
 
     class ga4gh(Ga4ghIdentifiableObject.ga4gh):
         prefix = "CX"
-        keys = ["copyChange", "location", "type"]
+        inherent = ["copyChange", "location", "type"]
 
 
 #########################################
@@ -993,6 +1000,6 @@ class SystemicVariation(RootModel):
 
 
 # At end so classes exist
-(reffable_classes, union_reffable_classes, class_refatt_map, class_keys) = (
+(reffable_classes, union_reffable_classes, class_refatt_map, class_inherent) = (
     pydantic_class_refatt_map()
 )