calm-data-generator 2.0.1__tar.gz → 2.2.0__tar.gz

{calm_data_generator-2.0.1/calm_data_generator.egg-info → calm_data_generator-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calm-data-generator
-Version: 2.0.1
+Version: 2.2.0
 Summary: CALM-Data-Generator: A Python library for synthetic data generation with support for drift injection and clinical data.
 Author-email: Alejandro Belda Fernandez <alejandrobeldafernandez@gmail.com>
 License: MIT
@@ -40,6 +40,7 @@ Requires-Dist: imbalanced-learn<0.15.0,>=0.14.0
 Requires-Dist: copulae<0.8.0,>=0.7.9
 Requires-Dist: anndata<0.12.0,>=0.11.0
 Requires-Dist: scvi-tools<1.4.0,>=1.3.0
+Requires-Dist: scanpy<1.11.0,>=1.10.0
 Requires-Dist: lightning<2.4.0,>=2.3.0
 Requires-Dist: torchmetrics<1.9.0,>=1.8.0
 Requires-Dist: plotly<6.6.0,>=6.5.0
@@ -52,6 +53,7 @@ Requires-Dist: hmmlearn<0.4.0,>=0.3.0
 Requires-Dist: pyarrow<15.0.0,>=14.0.0
 Requires-Dist: setuptools<70.0.0,>=59.0.0
 Requires-Dist: fsspec<2026.0.0,>=2025.12.0
+Requires-Dist: scgft-evaluator<0.2.0,>=0.1.0
 Provides-Extra: stream
 Requires-Dist: river>=0.21.0; extra == "stream"
 Provides-Extra: full
@@ -587,6 +589,26 @@ synthetic = gen.generate(
 |--------|----------|
 | `scvi` | Generate new cells from learned distribution |
 
+Once you have synthetic single-cell data, validate its quality using [scGFT Evaluator](https://github.com/nasim23ea/scgft-evaluator) via `QualityReporter`:
+
+```python
+from calm_data_generator.reports.QualityReporter import QualityReporter
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter = QualityReporter(verbose=True)
+reporter.generate_comprehensive_report(
+    real_df=real_df,
+    synthetic_df=synthetic_df,
+    generator_name="SingleCell_Example",
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type",
+    ),
+)
+```
+
+> See [REPORTS_REFERENCE.md](calm_data_generator/docs/REPORTS_REFERENCE.md#single-cell-evaluation-scgft) for full details.
 
 ### Stream Data Generation
 
@@ -624,6 +646,24 @@ reporter.generate_report(
 # Results JSON (including compared_data_files) saved to ./quality_report/report_results.json
 ```
 
+For **single-cell data**, enable [scGFT](https://github.com/nasim23ea/scgft-evaluator) evaluation (Graph Fourier Transform-based manifold preservation metrics):
+
+```python
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter.generate_comprehensive_report(
+    real_df=real_df,
+    synthetic_df=synthetic_df,
+    generator_name="MyGen",
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type",
+    ),
+)
+# Generates scgft_report.html with ARI, MMD, Jaccard, Kendall Tau metrics
+```
+
 ---
 
 ## Modules
@@ -759,3 +799,4 @@ We stand on the shoulders of giants. This library is possible thanks to these am
 - **[Hugging Face Hub](https://github.com/huggingface/huggingface_hub)** (Apache-2.0) - Facilitating model sharing and versioning.
 - **[Plotly](https://github.com/plotly/plotly.py)** (MIT) - Enabling interactive data visualizations.
 - **[hmmlearn](https://github.com/hmmlearn/hmmlearn)** (BSD-3-Clause) - Powering the `hmm` method for drift-aware generation via Hidden Markov Models.
+- **[scgft-evaluator](https://github.com/nasim23ea/scgft-evaluator)** - Providing Graph Fourier Transform-based evaluation for single-cell synthetic data quality assessment.

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/README.md

@@ -527,6 +527,26 @@ synthetic = gen.generate(
 |--------|----------|
 | `scvi` | Generate new cells from learned distribution |
 
+Once you have synthetic single-cell data, validate its quality using [scGFT Evaluator](https://github.com/nasim23ea/scgft-evaluator) via `QualityReporter`:
+
+```python
+from calm_data_generator.reports.QualityReporter import QualityReporter
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter = QualityReporter(verbose=True)
+reporter.generate_comprehensive_report(
+    real_df=real_df,
+    synthetic_df=synthetic_df,
+    generator_name="SingleCell_Example",
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type",
+    ),
+)
+```
+
+> See [REPORTS_REFERENCE.md](calm_data_generator/docs/REPORTS_REFERENCE.md#single-cell-evaluation-scgft) for full details.
 
 ### Stream Data Generation
 
@@ -564,6 +584,24 @@ reporter.generate_report(
 # Results JSON (including compared_data_files) saved to ./quality_report/report_results.json
 ```
 
+For **single-cell data**, enable [scGFT](https://github.com/nasim23ea/scgft-evaluator) evaluation (Graph Fourier Transform-based manifold preservation metrics):
+
+```python
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter.generate_comprehensive_report(
+    real_df=real_df,
+    synthetic_df=synthetic_df,
+    generator_name="MyGen",
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type",
+    ),
+)
+# Generates scgft_report.html with ARI, MMD, Jaccard, Kendall Tau metrics
+```
+
 ---
 
 ## Modules
@@ -699,3 +737,4 @@ We stand on the shoulders of giants. This library is possible thanks to these am
 - **[Hugging Face Hub](https://github.com/huggingface/huggingface_hub)** (Apache-2.0) - Facilitating model sharing and versioning.
 - **[Plotly](https://github.com/plotly/plotly.py)** (MIT) - Enabling interactive data visualizations.
 - **[hmmlearn](https://github.com/hmmlearn/hmmlearn)** (BSD-3-Clause) - Powering the `hmm` method for drift-aware generation via Hidden Markov Models.
+- **[scgft-evaluator](https://github.com/nasim23ea/scgft-evaluator)** - Providing Graph Fourier Transform-based evaluation for single-cell synthetic data quality assessment.

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/__init__.py

@@ -13,7 +13,7 @@ try:
 except ImportError:
     StreamGenerator = None
 
-__version__ = "2.0.1"
+__version__ = "2.1.0"
 
 __all__ = [
     # Generators

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/cli.py

@@ -103,6 +103,9 @@ def show_tutorial(number):
 
 def run_tutorial(number):
     """Run a specific tutorial."""
+    import subprocess
+    import sys
+
     tutorials_dir = get_tutorials_dir()
     tutorials = sorted(tutorials_dir.glob("*.py"))
 
@@ -114,15 +117,21 @@ def run_tutorial(number):
         idx = int(number) - 1
         if 0 <= idx < len(tutorials):
             tutorial = tutorials[idx]
-            print(f"\n🚀 Running: {tutorial.name}")
+            print(f"\n Running: {tutorial.name}")
             print("=" * 60)
-            exec(open(tutorial).read())
+            # Run in a subprocess to keep the tutorial isolated from this process
+            result = subprocess.run(
+                [sys.executable, str(tutorial)],
+                check=False,
+            )
+            if result.returncode != 0:
+                print(f"Tutorial exited with code {result.returncode}")
         else:
-            print(f"❌ Invalid tutorial number. Choose 1-{len(tutorials)}")
+            print(f"Invalid tutorial number. Choose 1-{len(tutorials)}")
     except ValueError:
-        print("❌ Please provide a tutorial number (e.g., 1, 2, 3)")
+        print("Please provide a tutorial number (e.g., 1, 2, 3)")
     except Exception as e:
-        print(f"❌ Error running tutorial: {e}")
+        print(f"Error running tutorial: {e}")
 
 
 def show_path():

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/docs/PRESETS_REFERENCE.md

@@ -521,6 +521,27 @@ preset = SingleCellQualityPreset(random_state=42)
 synthetic_cells = preset.generate(data=adata_df, n_samples=500)
 ```
 
+To validate the generated data quality, use `QualityReporter` with scGFT enabled:
+
+```python
+from calm_data_generator.reports.QualityReporter import QualityReporter
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter = QualityReporter(verbose=True)
+reporter.generate_comprehensive_report(
+    real_df=adata_df,
+    synthetic_df=synthetic_cells,
+    generator_name="SingleCellQualityPreset",
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type",
+    ),
+)
+```
+
+> See [REPORTS_REFERENCE.md](REPORTS_REFERENCE.md#single-cell-evaluation-scgft) for full scGFT documentation.
+
 ---
 
 ## Import Summary

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/docs/PRESETS_REFERENCE_ES.md

@@ -521,6 +521,27 @@ preset = SingleCellQualityPreset(random_state=42)
 synthetic_cells = preset.generate(data=adata_df, n_samples=500)
 ```
 
+Para validar la calidad de los datos generados, usa `QualityReporter` con scGFT activado:
+
+```python
+from calm_data_generator.reports.QualityReporter import QualityReporter
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter = QualityReporter(verbose=True)
+reporter.generate_comprehensive_report(
+    real_df=adata_df,
+    synthetic_df=synthetic_cells,
+    generator_name="SingleCellQualityPreset",
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type",
+    ),
+)
+```
+
+> Ver [REPORTS_REFERENCE_ES.md](REPORTS_REFERENCE_ES.md#evaluación-single-cell-scgft) para documentación completa de scGFT.
+
 ---
 
 ## Resumen de Imports

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/docs/REAL_GENERATOR_REFERENCE.md

@@ -560,14 +560,70 @@ synthetic = gen.generate(
 )
 ```
 
-| Parameter | Default | Description |
-|-----------|---------|-------------|
-| `target_col` | **required** | Column name with cell type labels |
-| `epochs` | 200 | Training epochs for the base scVI model |
-| `n_latent` | 30 | Latent space dimensionality |
-| `n_layers` | 1 | Number of encoder/decoder layers |
 | `custom_distributions` | `None` | Per-class proportions for generation |
 
+#### Single-Cell Workflow Utilities
+
+For users working with single-cell transcriptomics, `RealGenerator` provides a utility to convert the generated synthetic DataFrames back into `AnnData` objects, which are the standard format for analysis libraries like `scanpy` or `squidpy`.
+
+**`to_anndata(df, target_col=None, obs_cols=None)`** (Static Method)
+
+Converts a synthetic DataFrame (the output of `generate()`) into an `AnnData` object.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `df` | `pd.DataFrame` | **required** | The synthetic DataFrame generated by `calm_data_generator`. |
+| `target_col` | `str` | `None` | The column to be used as `cell_type` in `adata.obs`. |
+| `obs_cols` | `List[str]` | `None` | List of additional columns to move from the feature matrix (`X`) to the metadata (`obs`). |
+
+**Example:**
+```python
+from calm_data_generator.generators.tabular import RealGenerator
+
+# 1. Generate synthetic data (e.g., using scVI)
+synthetic_df = gen.generate(
+    data=real_adata,
+    n_samples=2000,
+    method="scvi",
+    target_col="cell_type"
+)
+
+# 2. Convert back to AnnData for scanpy analysis
+synthetic_adata = RealGenerator.to_anndata(
+    synthetic_df, 
+    target_col="cell_type"
+)
+
+# 3. Standard scanpy analysis
+import scanpy as sc
+sc.pp.pca(synthetic_adata)
+sc.pl.pca(synthetic_adata, color="cell_type")
+```
+
+**Validating single-cell quality with scGFT:**
+
+After generating synthetic single-cell data, validate its fidelity using [scgft-evaluator](https://github.com/nasim23ea/scgft-evaluator):
+
+```python
+from calm_data_generator.reports.QualityReporter import QualityReporter
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter = QualityReporter(verbose=True)
+reporter.generate_comprehensive_report(
+    real_df=real_df,
+    synthetic_df=synthetic_df,
+    generator_name="scVI_SingleCell",
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type",
+    ),
+)
+# Generates scgft_report.html with ARI, MMD, Jaccard, Kendall Tau metrics
+```
+
+> See [REPORTS_REFERENCE.md](REPORTS_REFERENCE.md#single-cell-evaluation-scgft) for full details.
+
 ---
 
 ---

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/docs/REAL_GENERATOR_REFERENCE_ES.md

@@ -195,8 +195,69 @@ synthetic = gen.generate(
 
 
 
----
+| `custom_distributions` | `None` | Proporciones por clase para la generación |
+
+#### Utilidades de Flujo de Trabajo para Single-Cell
+
+Para los usuarios que trabajan con transcriptómica de célula única (single-cell), `RealGenerator` proporciona una utilidad para convertir los DataFrames sintéticos generados de vuelta a objetos `AnnData`, que es el formato estándar para librerías de análisis como `scanpy` o `squidpy`.
+
+**`to_anndata(df, target_col=None, obs_cols=None)`** (Método Estático)
+
+Convierte un DataFrame sintético (la salida de `generate()`) en un objeto `AnnData`.
+
+| Parámetro | Tipo | Defecto | Descripción |
+|-----------|------|---------|-------------|
+| `df` | `pd.DataFrame` | **requerido** | El DataFrame sintético generado por `calm_data_generator`. |
+| `target_col` | `str` | `None` | La columna que se usará como `cell_type` en `adata.obs`. |
+| `obs_cols` | `List[str]` | `None` | Lista de columnas adicionales que se moverán de la matriz de características (`X`) a los metadatos (`obs`). |
+
+**Ejemplo:**
+```python
+from calm_data_generator.generators.tabular import RealGenerator
+
+# 1. Generar datos sintéticos (ej. usando scANVI)
+synthetic_df = gen.generate(
+    data=real_adata,
+    n_samples=2000,
+    method="scanvi",
+    target_col="cell_type"
+)
+
+# 2. Convertir de vuelta a AnnData para análisis con scanpy
+synthetic_adata = RealGenerator.to_anndata(
+    synthetic_df, 
+    target_col="cell_type"
+)
+
+# 3. Análisis estándar con scanpy
+import scanpy as sc
+sc.pp.pca(synthetic_adata)
+sc.pl.pca(synthetic_adata, color="cell_type")
+```
+
+**Validación de calidad single-cell con scGFT:**
+
+Tras generar datos sintéticos de célula única, valida su fidelidad usando [scgft-evaluator](https://github.com/nasim23ea/scgft-evaluator):
+
+```python
+from calm_data_generator.reports.QualityReporter import QualityReporter
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter = QualityReporter(verbose=True)
+reporter.generate_comprehensive_report(
+    real_df=real_df,
+    synthetic_df=synthetic_df,
+    generator_name="scVI_SingleCell",
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type",
+    ),
+)
+# Genera scgft_report.html con métricas ARI, MMD, Jaccard, Kendall Tau
+```
 
+> Ver [REPORTS_REFERENCE_ES.md](REPORTS_REFERENCE_ES.md#evaluación-single-cell-scgft) para documentación completa.
 
 ---
 

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/docs/REPORTS_REFERENCE.md

@@ -27,6 +27,7 @@ The `calm_data_generator` library includes a suite of reporting tools designed t
 | `constraints_stats` | Dict[str, int] | `None` | Constraint violation statistics |
 | `sequence_config` | Dict | `None` | Configuration for sequence-based analysis |
 | `per_block_external_reports` | bool | `False` | Generate separate reports per block |
+| `use_scgft` | bool | `False` | Enable specialized scGFT single-cell evaluation |
 
 ### Usage Examples
 
@@ -173,6 +174,50 @@ reporter.generate_report(
 ```
 
 
+## Single-Cell Evaluation (scGFT)
+**Module:** `calm_data_generator.reports.QualityReporter`
+
+The library integrates [`scgft-evaluator`](https://github.com/nasim23ea/scgft-evaluator) to provide specialized validation for single-cell RNA sequencing (scRNA-seq) data. This method uses Graph Fourier Transforms (GFT) to assess if the synthetic data preserves the underlying manifold and biological structure of the original cells.
+
+### Installation
+
+```bash
+pip install scgft-evaluator @ git+https://github.com/nasim23ea/scgft-evaluator.git
+```
+
+Or via `requirements.txt` (already included in calm-data-generator):
+
+```
+scgft-evaluator @ git+https://github.com/nasim23ea/scgft-evaluator.git
+```
+
+### Key Features
+- **Manifold Preservation**: Evaluates if the cell-to-cell relationships are maintained.
+- **Cluster/Population Integrity**: Metrics on how well synthetic cells represent real populations (ARI, MMD, Jaccard, Kendall Tau).
+- **Limma-based DE comparison**: Differential expression concordance between real and synthetic via `limma`.
+- **Dashboard Integration**: Generates a dedicated `scgft_report.html` tab in the HTML dashboard with a results table.
+
+### Usage
+Set `use_scgft=True` in your `ReportConfig` and specify the cell-type column:
+
+```python
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter.generate_comprehensive_report(
+    ...,
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type"  # column with cell type labels
+    )
+)
+```
+
+The evaluator runs `ScGFT_Evaluator.run_all()` comparing the two most prevalent cell populations and prints a metrics table when `verbose=True`.
+
+> [!IMPORTANT]
+> **Data Format**: This method is specifically designed for single-cell data where columns represent genes and rows represent cells. It is **not recommended** for standard bulk or tabular data.
+
 ## Clinic Reporter (`Clinical`)
 **Module:** `calm_data_generator.generators.clinical.ClinicReporter`
 

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/docs/REPORTS_REFERENCE_ES.md

@@ -27,6 +27,7 @@ La biblioteca `calm_data_generator` incluye un conjunto de herramientas de repor
 | `constraints_stats` | Dict[str, int] | `None` | Estadísticas de violación de restricciones |
 | `sequence_config` | Dict | `None` | Configuración para análisis basado en secuencias |
 | `per_block_external_reports` | bool | `False` | Generar reportes separados por bloque |
+| `use_scgft` | bool | `False` | Habilitar evaluación especializada scGFT para single-cell |
 
 ### Ejemplos de Uso
 
@@ -173,6 +174,50 @@ reporter.generate_report(
 ```
 
 
+## Evaluación Single-Cell (scGFT)
+**Módulo:** `calm_data_generator.reports.QualityReporter`
+
+La biblioteca integra [`scgft-evaluator`](https://github.com/nasim23ea/scgft-evaluator) para proporcionar validación especializada para datos de secuenciación de ARN de célula única (scRNA-seq). Este método utiliza Transformadas de Fourier en Grafos (GFT) para evaluar si los datos sintéticos preservan el manifold subyacente y la estructura biológica de las células originales.
+
+### Instalación
+
+```bash
+pip install scgft-evaluator @ git+https://github.com/nasim23ea/scgft-evaluator.git
+```
+
+O mediante `requirements.txt` (ya incluido en calm-data-generator):
+
+```
+scgft-evaluator @ git+https://github.com/nasim23ea/scgft-evaluator.git
+```
+
+### Características Clave
+- **Preservación del Manifold**: Evalúa si se mantienen las relaciones célula a célula.
+- **Integridad de Clusters/Poblaciones**: Métricas sobre qué tan bien las células sintéticas representan las poblaciones reales (ARI, MMD, Jaccard, Tau de Kendall).
+- **Comparación DE basada en limma**: Concordancia de expresión diferencial entre real y sintético vía `limma`.
+- **Integración en el Dashboard**: Genera una pestaña dedicada `scgft_report.html` en el panel HTML con tabla de resultados.
+
+### Uso
+Establezca `use_scgft=True` en su `ReportConfig` e indique la columna de tipo celular:
+
+```python
+from calm_data_generator.generators.configs import ReportConfig
+
+reporter.generate_comprehensive_report(
+    ...,
+    report_config=ReportConfig(
+        output_dir="./sc_report",
+        use_scgft=True,
+        target_column="cell_type"  # columna con las etiquetas de tipo celular
+    )
+)
+```
+
+El evaluador ejecuta `ScGFT_Evaluator.run_all()` comparando las dos poblaciones celulares más frecuentes e imprime una tabla de métricas cuando `verbose=True`.
+
+> [!IMPORTANT]
+> **Formato de Datos**: Este método está diseñado específicamente para datos de célula única donde las columnas representan genes y las filas representan células. **No se recomienda** para datos estándar de bulk o tabulares.
+
 ## Reporter Clínico (`Clinical`)
 **Módulo:** `calm_data_generator.generators.clinical.ClinicReporter`
 

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/generators/clinical/Clinic.py

@@ -451,6 +451,18 @@ class ClinicalDataGenerator(ComplexGenerator):
 
         return df_temp, raw_demographic_data
 
+    def _apply_constraints(self, df: pd.DataFrame, constraints: List[Dict]) -> pd.DataFrame:
+        mask = pd.Series(True, index=df.index)
+        for c in constraints:
+            col, op, val = c.get("col"), c.get("op"), c.get("val")
+            if col not in df.columns: continue
+            if op == ">=": mask &= df[col] >= val
+            elif op == "<=": mask &= df[col] <= val
+            elif op == "==": mask &= df[col] == val
+            elif op == ">": mask &= df[col] > val
+            elif op == "<": mask &= df[col] < val
+        return df[mask].copy()
+
     def _prepare_demographic_context(
         self,
         demographic_df,
@@ -1293,15 +1305,15 @@ class ClinicalDataGenerator(ComplexGenerator):
         if not patient_ids_to_modify:
             return updated_demographic_df, updated_omics_data_df
 
-        # Update demographic data
-        for patient_id in patient_ids_to_modify:
-            current_group = updated_demographic_df.loc[patient_id, "Group"]
-            new_group = "Disease" if current_group == "Control" else "Control"
-            updated_demographic_df.loc[patient_id, "Group"] = new_group
-            if "Binary_Group" in updated_demographic_df.columns:
-                updated_demographic_df.loc[patient_id, "Binary_Group"] = (
-                    1 if new_group == "Disease" else 0
-                )
+        # Update demographic data (vectorized)
+        modify_idx = pd.Index(patient_ids_to_modify)
+        mask_control = updated_demographic_df.loc[modify_idx, "Group"] == "Control"
+        mask_disease = ~mask_control
+        updated_demographic_df.loc[modify_idx[mask_control], "Group"] = "Disease"
+        updated_demographic_df.loc[modify_idx[mask_disease], "Group"] = "Control"
+        if "Binary_Group" in updated_demographic_df.columns:
+            updated_demographic_df.loc[modify_idx[mask_control], "Binary_Group"] = 1
+            updated_demographic_df.loc[modify_idx[mask_disease], "Binary_Group"] = 0
 
         # Regenerate omics data for all transitioned patients
         if patient_ids_to_modify:

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/generators/configs.py

@@ -108,3 +108,5 @@ class ReportConfig(BaseModel):
     constraints_stats: Optional[Dict[str, int]] = None
     sequence_config: Optional[Dict] = None
     per_block_external_reports: bool = False
+    use_scgft: bool = False
+

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/generators/drift/DriftInjector.py

@@ -552,16 +552,17 @@ class DriftInjector:
         if len(idxs) == 0:
             return s
 
-        # for each row to change, choose a different category
-        current = s.loc[idxs].to_numpy()
-        new_vals = []
-        for cur in current:
-            choices = [u for u in uniques if u != cur]
+        # for each row to change, choose a different category (vectorized by value group)
+        current = s.loc[idxs]
+        result_vals = current.copy()
+        for uval in uniques:
+            sub_idx = current.index[current == uval]
+            if len(sub_idx) == 0:
+                continue
+            choices = [u for u in uniques if u != uval]
             if choices:
-                new_vals.append(rng.choice(choices))
-            else:
-                new_vals.append(cur)
-        s.loc[idxs] = new_vals
+                result_vals.loc[sub_idx] = rng.choice(choices, size=len(sub_idx))
+        s.loc[idxs] = result_vals
         return s
 
     def _validate_feature_op(self, drift_type: str, drift_magnitude: float):
@@ -1755,7 +1756,7 @@ class DriftInjector:
                 try:
                     df_drift = method(**params)
                 except Exception as e:
-                    print(f"Failed to apply {method_name}: {e}")
+                    warnings.warn(f"Failed to apply {method_name}: {e}")
             else:
                 print(f"Method {method_name} not found")
 
@@ -2024,7 +2025,7 @@ class DriftInjector:
         Returns:
             pd.DataFrame: The drifted dataframe.
         """
-        current_df = df.copy()
+        current_df = df
 
         for i, config in enumerate(schedule):
             method_name = "inject_feature_drift"
@@ -2208,8 +2209,7 @@ class DriftInjector:
                     time_col=time_col,
                 )
             except Exception as e:
-                import warnings as _w
-                _w.warn(f"inject_functional_drift: report failed: {e}")
+                warnings.warn(f"inject_functional_drift: report failed: {e}")
 
         return df_result
 
@@ -2320,8 +2320,7 @@ class DriftInjector:
                     time_col=time_col,
                 )
             except Exception as e:
-                import warnings as _w
-                _w.warn(f"inject_causal_cascade: report failed: {e}")
+                warnings.warn(f"inject_causal_cascade: report failed: {e}")
 
         return df_result
 

{calm_data_generator-2.0.1 → calm_data_generator-2.2.0}/calm_data_generator/generators/dynamics/ScenarioInjector.py

@@ -283,10 +283,30 @@ class ScenarioInjector:
 
         # 1. Calculate Raw Score
         if isinstance(formula, str):
+            # Validate the formula before calling eval().
+            # Only allow identifiers that are actual column names plus arithmetic
+            # operators and numeric literals — this prevents arbitrary code execution.
+            import re as _re
+            _allowed_pattern = _re.compile(
+                r"^[\w\s\.\+\-\*\/\(\)\,\d\.\>\<\=\!]+$"
+            )
+            if not _allowed_pattern.match(formula):
+                raise ValueError(
+                    f"Formula '{formula}' contains disallowed characters. "
+                    "Only column names, numeric literals, and arithmetic operators "
+                    "(+, -, *, /, parentheses, inequalities) are permitted."
+                )
+            # Additionally verify that every identifier in the formula is an
+            # existing column name or a numeric token, not an arbitrary name.
+            _tokens = _re.findall(r"[A-Za-z_]\w*", formula)
+            _unknown = [t for t in _tokens if t not in df_target.columns]
+            if _unknown:
+                raise ValueError(
+                    f"Formula references unknown identifiers: {_unknown}. "
+                    f"Available columns: {list(df_target.columns)}"
+                )
             try:
-                # Use pandas eval for string formulas
-                # We perform eval in the context of the dataframe
-                raw_score = df_target.eval(formula)
+                raw_score = df_target.eval(formula, engine="python")
             except Exception as e:
                 raise ValueError(f"Error evaluating formula '{formula}': {e}")
         elif callable(formula):