phylogenie 2.1.4__py3-none-any.whl → 3.1.7__py3-none-any.whl

phylogenie/generators/alisim.py

@@ -6,9 +6,9 @@ from typing import Any, Literal
 from numpy.random import Generator, default_rng
 
 from phylogenie.generators.dataset import DatasetGenerator, DataType
-from phylogenie.generators.factories import data
+from phylogenie.generators.factories import data, string
 from phylogenie.generators.trees import TreeDatasetGeneratorConfig
-from phylogenie.io import dump_newick
+from phylogenie.treesimulator import dump_newick, get_node_depths
 
 MSAS_DIRNAME = "MSAs"
 TREES_DIRNAME = "trees"
@@ -19,7 +19,7 @@ class AliSimDatasetGenerator(DatasetGenerator):
     trees: TreeDatasetGeneratorConfig
     keep_trees: bool = False
     iqtree_path: str = "iqtree2"
-    args: dict[str, str | int | float]
+    args: dict[str, Any]
 
     def _generate_one_from_tree(
         self, filename: str, tree_file: str, rng: Generator, data: dict[str, Any]
@@ -35,9 +35,7 @@ class AliSimDatasetGenerator(DatasetGenerator):
         ]
 
         for key, value in self.args.items():
-            command.extend(
-                [key, value.format(**data) if isinstance(value, str) else str(value)]
-            )
+            command.extend([key, string(value, data)])
 
         command.extend(["-af", "fasta"])
         subprocess.run(command, check=True, stdout=subprocess.DEVNULL)
@@ -61,24 +59,26 @@ class AliSimDatasetGenerator(DatasetGenerator):
             tree_filename = f"{filename}.temp-tree"
             msa_filename = filename
 
-        d: dict[str, Any] = {"file_id": Path(msa_filename).stem}
+        md: dict[str, Any] = {"file_id": Path(msa_filename).stem}
         rng = default_rng(seed)
         while True:
-            d.update(data(context, rng))
+            md.update(data(context, rng))
             try:
-                tree = self.trees.simulate_one(d, seed)
+                tree, metadata = self.trees.simulate_one(md, seed)
                 break
             except TimeoutError:
                 print(
                     "Tree simulation timed out, retrying with different parameters..."
                 )
+        md.update(metadata)
 
+        times = get_node_depths(tree)
         for leaf in tree.get_leaves():
-            leaf.id += f"|{leaf.get_time()}"
+            leaf.name += f"|{times[leaf]}"
         dump_newick(tree, f"{tree_filename}.nwk")
 
-        self._generate_one_from_tree(msa_filename, f"{tree_filename}.nwk", rng, d)
+        self._generate_one_from_tree(msa_filename, f"{tree_filename}.nwk", rng, md)
         if not self.keep_trees:
             os.remove(f"{tree_filename}.nwk")
 
-        return d
+        return md

phylogenie/generators/configs.py

@@ -1,6 +1,28 @@
+from typing import Any
+
+from numpy.random import Generator
+from pydantic import BaseModel, ConfigDict
+
 import phylogenie.typings as pgt
-from phylogenie.treesimulator import MutationTargetType
-from phylogenie.utils import Distribution, StrictBaseModel
+from phylogenie.treesimulator import EventType
+
+
+class StrictBaseModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class Distribution(BaseModel):
+    type: str
+    model_config = ConfigDict(extra="allow")
+
+    @property
+    def args(self) -> dict[str, Any]:
+        assert self.model_extra is not None
+        return self.model_extra
+
+    def __call__(self, rng: Generator) -> Any:
+        return getattr(rng, self.type)(**self.args)
+
 
 Integer = str | int
 Scalar = str | pgt.Scalar
@@ -30,9 +52,9 @@ SkylineMatrix = str | pgt.Scalar | pgt.Many[SkylineVector] | SkylineMatrixModel
 
 
 class Event(StrictBaseModel):
-    states: str | list[str] | None = None
+    state: str | None = None
     rate: SkylineParameter
 
 
 class Mutation(Event):
-    rate_scalers: dict[MutationTargetType, Distribution]
+    rate_scalers: dict[EventType, Distribution]

phylogenie/generators/dataset.py

@@ -8,7 +8,7 @@ import pandas as pd
 from numpy.random import Generator, default_rng
 from tqdm import tqdm
 
-from phylogenie.utils import Distribution, StrictBaseModel
+from phylogenie.generators.configs import Distribution, StrictBaseModel
 
 
 class DataType(str, Enum):
@@ -31,7 +31,7 @@ class DatasetGenerator(ABC, StrictBaseModel):
     def generate_one(
         self,
         filename: str,
-        context: dict[str, Any] | None = None,
+        context: dict[str, Distribution] | None = None,
         seed: int | None = None,
     ) -> dict[str, Any]: ...
 
@@ -56,7 +56,7 @@ class DatasetGenerator(ABC, StrictBaseModel):
             for i in range(n_samples)
         )
         df = pd.DataFrame(
-            [r for r in tqdm(jobs, total=n_samples, desc=f"Generating {data_dir}...")]
+            [j for j in tqdm(jobs, f"Generating {data_dir}...", n_samples)]
         )
         df.to_csv(os.path.join(output_dir, METADATA_FILENAME), index=False)
 

phylogenie/generators/factories.py

@@ -1,4 +1,5 @@
-from typing import Any
+import re
+from typing import Any, Callable
 
 import numpy as np
 from numpy.random import Generator
@@ -15,18 +16,14 @@ from phylogenie.skyline import (
     SkylineVector,
     SkylineVectorCoercible,
 )
-from phylogenie.utils import Distribution
+from phylogenie.treesimulator import EventType, Mutation
 
 
 def _eval_expression(expression: str, data: dict[str, Any]) -> Any:
     return np.array(
         eval(
             expression,
-            {
-                "__builtins__": __builtins__,
-                "np": np,
-                **{k: np.array(v) for k, v in data.items()},
-            },
+            {"np": np, **{k: np.array(v) for k, v in data.items()}},
         )
     ).tolist()
 
@@ -53,6 +50,14 @@ def scalar(x: cfg.Scalar, data: dict[str, Any]) -> pgt.Scalar:
     return x
 
 
+def string(s: Any, data: dict[str, Any]) -> str:
+    if not isinstance(s, str):
+        return str(s)
+    return re.sub(
+        r"\{([^{}]+)\}", lambda match: str(_eval_expression(match.group(1), data)), s
+    )  # Match content inside curly braces
+
+
 def many_scalars(x: cfg.ManyScalars, data: dict[str, Any]) -> pgt.ManyScalars:
     if isinstance(x, str):
         e = _eval_expression(x, data)
@@ -204,19 +209,40 @@ def skyline_matrix(
     return SkylineMatrix(value=value, change_times=change_times)
 
 
-def distribution(x: Distribution, data: dict[str, Any]) -> Distribution:
+def distribution(x: cfg.Distribution, data: dict[str, Any]) -> cfg.Distribution:
     args = x.args
     for arg_name, arg_value in args.items():
         if isinstance(arg_value, str):
             args[arg_name] = _eval_expression(arg_value, data)
-    return Distribution(type=x.type, **args)
+    return cfg.Distribution(type=x.type, **args)
+
+
+def mutations(
+    x: list[cfg.Mutation],
+    data: dict[str, Any],
+    states: set[str],
+    rates_to_log: list[EventType] | None,
+    rng: Generator,
+) -> list[Mutation]:
+    mutations: list[Mutation] = []
+    for m in x:
+        rate = skyline_parameter(m.rate, data)
+        rate_scalers: dict[EventType, Callable[[], float]] = {
+            k: lambda: distribution(v, data)(rng) for k, v in m.rate_scalers.items()
+        }
+        if m.state is None:
+            mutations.extend(
+                Mutation(s, rate, rate_scalers, rates_to_log) for s in states
+            )
+        else:
+            mutations.append(Mutation(m.state, rate, rate_scalers, rates_to_log))
+    return mutations
 
 
-def data(context: dict[str, Distribution] | None, rng: Generator) -> dict[str, Any]:
+def data(context: dict[str, cfg.Distribution] | None, rng: Generator) -> dict[str, Any]:
     if context is None:
         return {}
     data: dict[str, Any] = {}
     for k, v in context.items():
-        dist = distribution(v, data)
-        data[k] = np.array(getattr(rng, dist.type)(**dist.args)).tolist()
+        data[k] = np.array(distribution(v, data)(rng)).tolist()
     return data

phylogenie/generators/trees.py

@@ -1,28 +1,30 @@
 from abc import abstractmethod
 from enum import Enum
 from pathlib import Path
-from typing import Annotated, Any, Literal
+from typing import Annotated, Any, Callable, Literal
 
 import numpy as np
 from numpy.random import default_rng
 from pydantic import Field
 
 import phylogenie.generators.configs as cfg
+from phylogenie.generators.configs import Distribution
 from phylogenie.generators.dataset import DatasetGenerator, DataType
 from phylogenie.generators.factories import (
     data,
-    distribution,
     integer,
+    mutations,
     scalar,
     skyline_matrix,
     skyline_parameter,
     skyline_vector,
 )
-from phylogenie.io import dump_newick
-from phylogenie.tree import Tree
 from phylogenie.treesimulator import (
     Event,
-    Mutation,
+    EventType,
+    Feature,
+    Tree,
+    dump_newick,
     get_BD_events,
     get_BDEI_events,
     get_BDSS_events,
@@ -30,6 +32,7 @@ from phylogenie.treesimulator import (
     get_contact_tracing_events,
     get_epidemiological_events,
     get_FBD_events,
+    set_features,
     simulate_tree,
 )
 
@@ -45,26 +48,42 @@ class ParameterizationType(str, Enum):
 
 class TreeDatasetGenerator(DatasetGenerator):
     data_type: Literal[DataType.TREES] = DataType.TREES
-    min_tips: cfg.Integer = 1
-    max_tips: cfg.Integer = 2**32
+    mutations: list[cfg.Mutation] = Field(default_factory=lambda: [])
+    rates_to_log: list[EventType] | None = None
+    n_tips: cfg.Integer | None = None
     max_time: cfg.Scalar = np.inf
     init_state: str | None = None
     sampling_probability_at_present: cfg.Scalar = 0.0
     timeout: float = np.inf
+    node_features: list[Feature] | None = None
+    acceptance_criterion: str | None = None
 
     @abstractmethod
     def _get_events(self, data: dict[str, Any]) -> list[Event]: ...
 
-    def simulate_one(self, data: dict[str, Any], seed: int | None = None) -> Tree:
+    def simulate_one(
+        self, data: dict[str, Any], seed: int | None = None
+    ) -> tuple[Tree, dict[str, Any]]:
         init_state = (
             self.init_state
             if self.init_state is None
             else self.init_state.format(**data)
         )
+        events = self._get_events(data)
+        states = {e.state for e in events}
+        events += mutations(
+            self.mutations, data, states, self.rates_to_log, default_rng(seed)
+        )
+        acceptance_criterion: None | Callable[[Tree], bool] = (
+            None
+            if self.acceptance_criterion is None
+            else lambda tree: eval(
+                self.acceptance_criterion, {}, {"tree": tree}  # pyright: ignore
+            )
+        )
         return simulate_tree(
-            events=self._get_events(data),
-            min_tips=integer(self.min_tips, data),
-            max_tips=integer(self.max_tips, data),
+            events=events,
+            n_tips=None if self.n_tips is None else integer(self.n_tips, data),
             max_time=scalar(self.max_time, data),
             init_state=init_state,
             sampling_probability_at_present=scalar(
@@ -72,12 +91,13 @@ class TreeDatasetGenerator(DatasetGenerator):
             ),
             seed=seed,
             timeout=self.timeout,
+            acceptance_criterion=acceptance_criterion,
         )
 
     def generate_one(
         self,
         filename: str,
-        context: dict[str, Any] | None = None,
+        context: dict[str, Distribution] | None = None,
         seed: int | None = None,
     ) -> dict[str, Any]:
         d = {"file_id": Path(filename).stem}
@@ -85,12 +105,14 @@ class TreeDatasetGenerator(DatasetGenerator):
         while True:
             try:
                 d.update(data(context, rng))
-                tree = self.simulate_one(d, seed)
+                tree, metadata = self.simulate_one(d, seed)
+                if self.node_features is not None:
+                    set_features(tree, self.node_features)
                 dump_newick(tree, f"{filename}.nwk")
                 break
             except TimeoutError:
                 print("Simulation timed out, retrying with different parameters...")
-        return d
+        return d | metadata
 
 
 class CanonicalTreeDatasetGenerator(TreeDatasetGenerator):
@@ -98,8 +120,8 @@ class CanonicalTreeDatasetGenerator(TreeDatasetGenerator):
         ParameterizationType.CANONICAL
     )
     states: list[str]
-    sampling_rates: cfg.SkylineVector
-    remove_after_sampling: bool
+    sampling_rates: cfg.SkylineVector = 0
+    remove_after_sampling: bool = False
     birth_rates: cfg.SkylineVector = 0
     death_rates: cfg.SkylineVector = 0
     migration_rates: cfg.SkylineMatrix = None
@@ -122,7 +144,7 @@ class CanonicalTreeDatasetGenerator(TreeDatasetGenerator):
 class FBDTreeDatasetGenerator(TreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.FBD] = ParameterizationType.FBD
     states: list[str]
-    sampling_proportions: cfg.SkylineVector
+    sampling_proportions: cfg.SkylineVector = 0
     diversification: cfg.SkylineVector = 0
     turnover: cfg.SkylineVector = 0
     migration_rates: cfg.SkylineMatrix = None
@@ -141,12 +163,11 @@ class FBDTreeDatasetGenerator(TreeDatasetGenerator):
         )
 
 
-class TreeDatasetGeneratorForEpidemiology(TreeDatasetGenerator):
+class ContactTracingTreeDatasetGenerator(TreeDatasetGenerator):
     max_notified_contacts: cfg.Integer = 1
     notification_probability: cfg.SkylineParameter = 0.0
-    sampling_rate_after_notification: cfg.SkylineParameter = np.inf
+    sampling_rate_after_notification: cfg.SkylineParameter = 2**32
     samplable_states_after_notification: list[str] | None = None
-    mutations: tuple[cfg.Mutation, ...] = Field(default_factory=tuple)
 
     @abstractmethod
     def _get_base_events(self, data: dict[str, Any]) -> list[Event]: ...
@@ -165,30 +186,10 @@ class TreeDatasetGeneratorForEpidemiology(TreeDatasetGenerator):
                 ),
                 samplable_states_after_notification=self.samplable_states_after_notification,
             )
-        all_states = list({e.state for e in events})
-        for mutation in self.mutations:
-            states = mutation.states
-            if isinstance(states, str):
-                states = [states]
-            elif states is None:
-                states = all_states
-            for state in states:
-                if state not in all_states:
-                    raise ValueError(
-                        f"Mutation state '{state}' is not found in states {all_states}."
-                    )
-                rate_scalers = {
-                    t: distribution(r, data) for t, r in mutation.rate_scalers.items()
-                }
-                events.append(
-                    Mutation(
-                        state, skyline_parameter(mutation.rate, data), rate_scalers
-                    )
-                )
         return events
 
 
-class EpidemiologicalTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
+class EpidemiologicalTreeDatasetGenerator(ContactTracingTreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.EPIDEMIOLOGICAL] = (
         ParameterizationType.EPIDEMIOLOGICAL
     )
@@ -214,11 +215,11 @@ class EpidemiologicalTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
         )
 
 
-class BDTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
+class BDTreeDatasetGenerator(ContactTracingTreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.BD] = ParameterizationType.BD
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter
-    sampling_proportion: cfg.SkylineParameter = 1
+    sampling_proportion: cfg.SkylineParameter
 
     def _get_base_events(self, data: dict[str, Any]) -> list[Event]:
         return get_BD_events(
@@ -228,12 +229,12 @@ class BDTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
         )
 
 
-class BDEITreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
+class BDEITreeDatasetGenerator(ContactTracingTreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.BDEI] = ParameterizationType.BDEI
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter
     incubation_period: cfg.SkylineParameter
-    sampling_proportion: cfg.SkylineParameter = 1
+    sampling_proportion: cfg.SkylineParameter
 
     def _get_base_events(self, data: dict[str, Any]) -> list[Event]:
         return get_BDEI_events(
@@ -244,13 +245,13 @@ class BDEITreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
         )
 
 
-class BDSSTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
+class BDSSTreeDatasetGenerator(ContactTracingTreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.BDSS] = ParameterizationType.BDSS
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter
     superspreading_ratio: cfg.SkylineParameter
     superspreaders_proportion: cfg.SkylineParameter
-    sampling_proportion: cfg.SkylineParameter = 1
+    sampling_proportion: cfg.SkylineParameter
 
     def _get_base_events(self, data: dict[str, Any]) -> list[Event]:
         return get_BDSS_events(

phylogenie/io/__init__.py

@@ -0,0 +1,3 @@
+from phylogenie.io.fasta import dump_fasta, load_fasta
+
+__all__ = ["load_fasta", "dump_fasta"]

phylogenie/io/fasta.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import Callable
+
+from phylogenie.msa import MSA, Sequence
+
+
+def load_fasta(
+    fasta_file: str | Path, extract_time_from_id: Callable[[str], float] | None = None
+) -> MSA:
+    sequences: list[Sequence] = []
+    with open(fasta_file, "r") as f:
+        for line in f:
+            if not line.startswith(">"):
+                raise ValueError(f"Invalid FASTA format: expected '>', got '{line[0]}'")
+            id = line[1:].strip()
+            time = None
+            if extract_time_from_id is not None:
+                time = extract_time_from_id(id)
+            elif "|" in id:
+                try:
+                    time = float(id.split("|")[-1])
+                except ValueError:
+                    pass
+            chars = next(f).strip()
+            sequences.append(Sequence(id, chars, time))
+    return MSA(sequences)
+
+
+def dump_fasta(msa: MSA | list[Sequence], fasta_file: str | Path) -> None:
+    with open(fasta_file, "w") as f:
+        sequences = msa.sequences if isinstance(msa, MSA) else msa
+        for seq in sequences:
+            f.write(f">{seq.id}\n")
+            f.write(f"{seq.chars}\n")

phylogenie/main.py

@@ -2,27 +2,44 @@ import os
 from argparse import ArgumentParser
 from glob import glob
 
-from pydantic import TypeAdapter
+from pydantic import TypeAdapter, ValidationError
 from yaml import safe_load
 
 from phylogenie.generators import DatasetGeneratorConfig
 from phylogenie.generators.dataset import DatasetGenerator
 
 
-def run(config_path: str) -> None:
+def _format_validation_error(e: ValidationError) -> str:
+    formatted_errors = [
+        f"- {'.'.join(str(loc) for loc in err['loc'])}: {err['msg']} ({err['type']})"
+        for err in e.errors()
+    ]
+    return "\n".join(formatted_errors)
+
+
+def _generate_from_config_file(config_file: str):
     adapter: TypeAdapter[DatasetGenerator] = TypeAdapter(DatasetGeneratorConfig)
+    with open(config_file, "r") as f:
+        try:
+            config = safe_load(f)
+        except Exception as e:
+            print(f"❌ Failed to parse {config_file}: {e}")
+            exit(-1)
+        try:
+            generator = adapter.validate_python(config)
+        except ValidationError as e:
+            print("❌ Invalid configuration:")
+            print(_format_validation_error(e))
+            exit(-1)
+    generator.generate()
 
+
+def run(config_path: str) -> None:
     if os.path.isdir(config_path):
         for config_file in glob(os.path.join(config_path, "**/*.yaml"), recursive=True):
-            with open(config_file, "r") as f:
-                config = safe_load(f)
-            generator = adapter.validate_python(config)
-            generator.generate()
+            _generate_from_config_file(config_file)
     else:
-        with open(config_path, "r") as f:
-            config = safe_load(f)
-        generator = adapter.validate_python(config)
-        generator.generate()
+        _generate_from_config_file(config_path)
 
 
 def main() -> None:

phylogenie/mixins.py

@@ -0,0 +1,33 @@
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Any
+
+
+class MetadataMixin:
+    def __init__(self) -> None:
+        self._metadata: dict[str, Any] = {}
+
+    @property
+    def metadata(self) -> Mapping[str, Any]:
+        return MappingProxyType(self._metadata)
+
+    def set(self, key: str, value: Any) -> None:
+        self._metadata[key] = value
+
+    def update(self, metadata: Mapping[str, Any]) -> None:
+        self._metadata.update(metadata)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._metadata.get(key, default)
+
+    def delete(self, key: str) -> None:
+        self._metadata.pop(key, None)
+
+    def clear(self) -> None:
+        self._metadata.clear()
+
+    def __getitem__(self, key: str) -> Any:
+        return self._metadata[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self._metadata[key] = value

phylogenie/skyline/matrix.py

@@ -33,7 +33,7 @@ class SkylineMatrix:
     ):
         if params is not None and value is None and change_times is None:
             if is_many_skyline_vectors_like(params):
-                self.params = [
+                self._params = [
                     p if isinstance(p, SkylineVector) else SkylineVector(p)
                     for p in params
                 ]
@@ -41,7 +41,7 @@ class SkylineMatrix:
                 raise TypeError(
                     f"It is impossible to create a SkylineMatrix from `params` {params} of type {type(params)}. Please provide a sequence composed of SkylineVectorLike objects (a SkylineVectorLike object can either be a SkylineVector or a sequence of scalars and/or SkylineParameters)."
                 )
-            lengths = {len(p) for p in self.params}
+            lengths = {len(p) for p in self._params}
             if len(lengths) > 1:
                 raise ValueError(
                     f"All `params` must have the same length to create a SkylineMatrix (got params={params} with lengths {lengths})."
@@ -57,7 +57,7 @@ class SkylineMatrix:
                 raise TypeError(
                     f"It is impossible to create a SkylineMatrix from `value` {value} of type {type(value)}. Please provide a nested (3D) sequence of scalar values."
                 )
-            self.params = [
+            self._params = [
                 SkylineVector(
                     value=[matrix[i] for matrix in value], change_times=change_times
                 )
@@ -68,6 +68,10 @@ class SkylineMatrix:
                 "Either `params` or both `value` and `change_times` must be provided to create a SkylineMatrix."
             )
 
+    @property
+    def params(self) -> tuple[SkylineVector, ...]:
+        return tuple(self._params)
+
     @property
     def n_rows(self) -> int:
         return len(self.params)
@@ -82,14 +86,14 @@ class SkylineMatrix:
 
     @property
     def change_times(self) -> pgt.Vector1D:
-        return sorted(set([t for row in self.params for t in row.change_times]))
+        return tuple(sorted(set([t for row in self.params for t in row.change_times])))
 
     @property
     def value(self) -> pgt.Vector3D:
-        return [self.get_value_at_time(t) for t in (0, *self.change_times)]
+        return tuple(self.get_value_at_time(t) for t in (0, *self.change_times))
 
     def get_value_at_time(self, time: pgt.Scalar) -> pgt.Vector2D:
-        return [param.get_value_at_time(time) for param in self.params]
+        return tuple(param.get_value_at_time(time) for param in self.params)
 
     def _operate(
         self,
@@ -185,7 +189,7 @@ class SkylineMatrix:
             raise TypeError(
                 f"It is impossible to set item of SkylineMatrix to value {value} of type {type(value)}. Please provide a SkylineVectorLike object (i.e., a SkylineVector or a sequence of scalars and/or SkylineParameters)."
             )
-        self.params[item] = skyline_vector(value, self.n_cols)
+        self._params[item] = skyline_vector(value, self.n_cols)
 
 
 def skyline_matrix(

phylogenie/skyline/parameter.py

@@ -52,12 +52,20 @@ class SkylineParameter:
                 f"`change_times` must be non-negative (got change_times={change_times})."
             )
 
-        self.value = [value[0]]
-        self.change_times: list[pgt.Scalar] = []
+        self._value = [value[0]]
+        self._change_times: list[pgt.Scalar] = []
         for i in range(1, len(value)):
             if value[i] != value[i - 1]:
-                self.value.append(value[i])
-                self.change_times.append(change_times[i - 1])
+                self._value.append(value[i])
+                self._change_times.append(change_times[i - 1])
+
+    @property
+    def value(self) -> pgt.Vector1D:
+        return tuple(self._value)
+
+    @property
+    def change_times(self) -> pgt.Vector1D:
+        return tuple(self._change_times)
 
     def get_value_at_time(self, t: pgt.Scalar) -> pgt.Scalar:
         if t < 0: