Add operators

Author: dweindl

petab/v2/core.py

@@ -12,6 +12,7 @@
     Field,
     ValidationInfo,
     field_validator,
+    model_validator,
 )
 
 from ..v1.lint import is_valid_identifier
@@ -199,19 +200,26 @@ def to_tsv(self, file_path: str | Path) -> None:
         df = self.to_dataframe()
         df.to_csv(file_path, sep="\t", index=False)
 
+    def __add__(self, other: Observable) -> ObservablesTable:
+        """Add an observable to the table."""
+        if not isinstance(other, Observable):
+            raise TypeError("Can only add Observable to ObservablesTable")
+        return ObservablesTable(observables=self.observables + [other])
+
+    def __iadd__(self, other: Observable) -> ObservablesTable:
+        """Add an observable to the table in place."""
+        if not isinstance(other, Observable):
+            raise TypeError("Can only add Observable to ObservablesTable")
+        self.observables.append(other)
+        return self
+
 
 class OperationType(str, Enum):
     """Operation types for model changes in the PEtab conditions table."""
 
     # TODO update names
     SET_CURRENT_VALUE = "setCurrentValue"
-    SET_RATE = "setRate"
-    SET_ASSIGNMENT = "setAssignment"
-    ADD_TO_RATE = "addToRate"
-    ADD_TO_ASSIGNMENT = "addToAssignment"
     NO_CHANGE = "noChange"
-    CONSTANT = "constant"
-    INITIAL = "initial"
     ...
 
 
@@ -222,23 +230,24 @@ class Change(BaseModel):
     row of the PEtab conditions table.
     """
 
-    target_id: str = Field(alias=C.TARGET_ID)
+    target_id: str | None = Field(alias=C.TARGET_ID, default=None)
     operation_type: OperationType = Field(alias=C.VALUE_TYPE)
-    target_value: sp.Basic = Field(alias=C.TARGET_VALUE)
+    target_value: sp.Basic | None = Field(alias=C.TARGET_VALUE, default=None)
 
     class Config:
         populate_by_name = True
         arbitrary_types_allowed = True
         use_enum_values = True
 
-    @field_validator("target_id")
+    @model_validator(mode="before")
     @classmethod
-    def validate_id(cls, v):
-        if not v:
-            raise ValueError("ID must not be empty.")
-        if not is_valid_identifier(v):
-            raise ValueError(f"Invalid ID: {v}")
-        return v
+    def validate_id(cls, data: dict):
+        if data.get("operation_type") != OperationType.NO_CHANGE:
+            target_id = data.get("target_id")
+
+            if not is_valid_identifier(target_id):
+                raise ValueError(f"Invalid ID: {target_id}")
+        return data
 
     @field_validator("target_value", mode="before")
     @classmethod
@@ -274,11 +283,24 @@ def validate_id(cls, v):
             raise ValueError(f"Invalid ID: {v}")
         return v
 
+    def __add__(self, other: Change) -> ChangeSet:
+        """Add a change to the set."""
+        if not isinstance(other, Change):
+            raise TypeError("Can only add Change to ChangeSet")
+        return ChangeSet(id=self.id, changes=self.changes + [other])
+
+    def __iadd__(self, other: Change) -> ChangeSet:
+        """Add a change to the set in place."""
+        if not isinstance(other, Change):
+            raise TypeError("Can only add Change to ChangeSet")
+        self.changes.append(other)
+        return self
+
 
 class ConditionsTable(BaseModel):
     """PEtab conditions table."""
 
-    conditions: list[ChangeSet]
+    conditions: list[ChangeSet] = []
 
     def __getitem__(self, condition_id: str) -> ChangeSet:
         """Get a condition by ID."""
@@ -316,6 +338,19 @@ def to_tsv(self, file_path: str | Path) -> None:
         df = self.to_dataframe()
         df.to_csv(file_path, sep="\t", index=False)
 
+    def __add__(self, other: ChangeSet) -> ConditionsTable:
+        """Add a condition to the table."""
+        if not isinstance(other, ChangeSet):
+            raise TypeError("Can only add ChangeSet to ConditionsTable")
+        return ConditionsTable(conditions=self.conditions + [other])
+
+    def __iadd__(self, other: ChangeSet) -> ConditionsTable:
+        """Add a condition to the table in place."""
+        if not isinstance(other, ChangeSet):
+            raise TypeError("Can only add ChangeSet to ConditionsTable")
+        self.conditions.append(other)
+        return self
+
 
 class ExperimentPeriod(BaseModel):
     """A period of a timecourse defined by a start time and a set changes.
@@ -348,7 +383,7 @@ class Experiment(BaseModel):
     """
 
     id: str = Field(alias=C.EXPERIMENT_ID)
-    periods: list[ExperimentPeriod]
+    periods: list[ExperimentPeriod] = []
 
     class Config:
         populate_by_name = True
@@ -363,6 +398,19 @@ def validate_id(cls, v):
             raise ValueError(f"Invalid ID: {v}")
         return v
 
+    def __add__(self, other: ExperimentPeriod) -> Experiment:
+        """Add a period to the experiment."""
+        if not isinstance(other, ExperimentPeriod):
+            raise TypeError("Can only add ExperimentPeriod to Experiment")
+        return Experiment(id=self.id, periods=self.periods + [other])
+
+    def __iadd__(self, other: ExperimentPeriod) -> Experiment:
+        """Add a period to the experiment in place."""
+        if not isinstance(other, ExperimentPeriod):
+            raise TypeError("Can only add ExperimentPeriod to Experiment")
+        self.periods.append(other)
+        return self
+
 
 class ExperimentsTable(BaseModel):
     """PEtab experiments table."""
@@ -398,6 +446,19 @@ def to_tsv(self, file_path: str | Path) -> None:
         df = self.to_dataframe()
         df.to_csv(file_path, sep="\t", index=False)
 
+    def __add__(self, other: Experiment) -> ExperimentsTable:
+        """Add an experiment to the table."""
+        if not isinstance(other, Experiment):
+            raise TypeError("Can only add Experiment to ExperimentsTable")
+        return ExperimentsTable(experiments=self.experiments + [other])
+
+    def __iadd__(self, other: Experiment) -> ExperimentsTable:
+        """Add an experiment to the table in place."""
+        if not isinstance(other, Experiment):
+            raise TypeError("Can only add Experiment to ExperimentsTable")
+        self.experiments.append(other)
+        return self
+
 
 class Measurement(BaseModel):
     """A measurement.
@@ -492,6 +553,19 @@ def to_tsv(self, file_path: str | Path) -> None:
         df = self.to_dataframe()
         df.to_csv(file_path, sep="\t", index=False)
 
+    def __add__(self, other: Measurement) -> MeasurementTable:
+        """Add a measurement to the table."""
+        if not isinstance(other, Measurement):
+            raise TypeError("Can only add Measurement to MeasurementTable")
+        return MeasurementTable(measurements=self.measurements + [other])
+
+    def __iadd__(self, other: Measurement) -> MeasurementTable:
+        """Add a measurement to the table in place."""
+        if not isinstance(other, Measurement):
+            raise TypeError("Can only add Measurement to MeasurementTable")
+        self.measurements.append(other)
+        return self
+
 
 class Mapping(BaseModel):
     """Mapping PEtab entities to model entities."""
@@ -542,6 +616,19 @@ def to_tsv(self, file_path: str | Path) -> None:
         df = self.to_dataframe()
         df.to_csv(file_path, sep="\t", index=False)
 
+    def __add__(self, other: Mapping) -> MappingTable:
+        """Add a mapping to the table."""
+        if not isinstance(other, Mapping):
+            raise TypeError("Can only add Mapping to MappingTable")
+        return MappingTable(mappings=self.mappings + [other])
+
+    def __iadd__(self, other: Mapping) -> MappingTable:
+        """Add a mapping to the table in place."""
+        if not isinstance(other, Mapping):
+            raise TypeError("Can only add Mapping to MappingTable")
+        self.mappings.append(other)
+        return self
+
 
 class Parameter(BaseModel):
     """Parameter definition."""
@@ -606,3 +693,16 @@ def from_tsv(cls, file_path: str | Path) -> ParameterTable:
     def to_tsv(self, file_path: str | Path) -> None:
         df = self.to_dataframe()
         df.to_csv(file_path, sep="\t", index=False)
+
+    def __add__(self, other: Parameter) -> ParameterTable:
+        """Add a parameter to the table."""
+        if not isinstance(other, Parameter):
+            raise TypeError("Can only add Parameter to ParameterTable")
+        return ParameterTable(parameters=self.parameters + [other])
+
+    def __iadd__(self, other: Parameter) -> ParameterTable:
+        """Add a parameter to the table in place."""
+        if not isinstance(other, Parameter):
+            raise TypeError("Can only add Parameter to ParameterTable")
+        self.parameters.append(other)
+        return self

tests/v2/test_core.py

@@ -1,7 +1,15 @@
 import tempfile
 from pathlib import Path
 
-from petab.v2.core import ConditionsTable, ObservablesTable
+from petab.v2.core import (
+    Change,
+    ChangeSet,
+    ConditionsTable,
+    Experiment,
+    ExperimentPeriod,
+    ObservablesTable,
+    OperationType,
+)
 from petab.v2.petab1to2 import petab1to2
 
 example_dir_fujita = Path(__file__).parents[2] / "doc/example/example_Fujita"
@@ -30,3 +38,40 @@ def test_conditions_table():
         conditions.to_tsv(tmp_file)
         conditions2 = ConditionsTable.from_tsv(tmp_file)
         assert conditions == conditions2
+
+
+def test_experiment_add_periods():
+    """Test operators for Experiment"""
+    exp = Experiment(id="exp1")
+    assert exp.periods == []
+
+    p1 = ExperimentPeriod(start=0, condition_id="p1")
+    p2 = ExperimentPeriod(start=1, condition_id="p2")
+    p3 = ExperimentPeriod(start=2, condition_id="p3")
+    exp += p1
+    exp += p2
+
+    assert exp.periods == [p1, p2]
+
+    exp2 = exp + p3
+    assert exp2.periods == [p1, p2, p3]
+    assert exp.periods == [p1, p2]
+
+
+def test_conditions_table_add_changeset():
+    conditions_table = ConditionsTable()
+    assert conditions_table.conditions == []
+
+    c1 = ChangeSet(
+        id="condition1",
+        changes=[Change(operation_type=OperationType.NO_CHANGE)],
+    )
+    c2 = ChangeSet(
+        id="condition2",
+        changes=[Change(operation_type=OperationType.NO_CHANGE)],
+    )
+
+    conditions_table += c1
+    conditions_table += c2
+
+    assert conditions_table.conditions == [c1, c2]