SimpleSEDML 0.0.1__py3-none-any.whl

__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

constants.py

@@ -0,0 +1,4 @@
+import os
+
+PROJECT_DIR = os.path.dirname(os.path.dirname(__file__))
+TEST_DIR = os.path.join(PROJECT_DIR, "tests")

model.py

@@ -0,0 +1,188 @@
+'''Class that handles model definitions and their parameters.'''
+
+import codecs
+import urllib3
+import os
+import tellurium as te  # type: ignore
+from typing import Optional, List
+import warnings
+
+SBML_STR = "sbml_str"
+ANT_STR = "ant_str"
+SBML_FILE = "sbml_file"
+ANT_FILE = "ant_file"
+SBML_URL = "sbml_url"
+MODEL_ID = "model_id"
+MODEL_REF_TYPES = [SBML_STR, ANT_STR, SBML_FILE, ANT_FILE, SBML_URL, MODEL_ID]
+
+"""
+Issues
+1. To eliminate the warning for urllib3, need to create a virtual environment with a higher version of python.
+"""
+
+class Model:
+    def __init__(self, id:str, model_ref:Optional[str]=None, ref_type:Optional[str]=None, 
+                 model_source:Optional[str]=None, 
+                 is_overwrite:bool=False,
+                 **kwargs):
+        """Provide information about the model and a model identifier.
+
+        Args:
+            id (str): identifier for the model
+            model_ref (str): reference to the file; reference type is specified separately
+            ref_type (str):
+                - "sbml_str": string representation of the SBML model
+                - "ant_str": string representation of the SBML model
+                - "sbml_file": file path to the SBML model
+                - "ant_file": file path to the Antimony model
+                - "sbml_url": URL to the SBML model
+                - "model_id": ID of a previously defined model
+            is_overwrite (bool): if True, overwrite the model if it already exists
+            model_source (str): source for the SBML model. If None, the source is a file with the same name as the model ID
+                in the current directory.
+        """
+        # Handle defaults
+        if model_ref is None:
+            # id is a file path to an SBML model
+            model_ref = id
+            _, filename = os.path.split(id)
+            splits = filename.split(".")
+            id = splits[0]
+            ref_type = SBML_FILE
+        elif ref_type is None:
+            ref_type = SBML_STR
+        # id, model_ref, ref_type should all be assigned
+        self.id = id
+        self.model_ref = model_ref
+        self.ref_type = ref_type
+        self.param_change_dct = kwargs
+        self.is_overwrite = is_overwrite
+        #
+        self.sbml_str = self._getSBMLFromReference()
+        self.model_source_path = self._makeModelSource(model_source)
+
+    def _makeModelSource(self, source:Optional[str])->str:
+        """Saves the model to a file. The file name is the model ID.
+        """
+        if self.ref_type == MODEL_ID:
+            # model_ref is the ID of a previously defined model
+            return self.model_ref
+        # FIXME: Model source should be the filename in the path
+        if source is None:
+            # Use the current directory
+            source = os.getcwd()
+            source = os.path.join(source, self.id)
+        source = str(source)
+        if self.is_overwrite or not os.path.exists(source):
+            with open(source, "wb") as f:
+                f.write(self.sbml_str.encode('utf-8'))
+                f.flush()
+                print(f"**Model saved to {source}")
+        if (not self.is_overwrite and os.path.exists(source)):
+            msg = "*** File {model_source_path} already exists and will be used as model source."
+            msg += "\n  Use is_overwrite=True to overwrite."
+            warnings.warn(msg)
+        return source
+
+    def _getSBMLFromReference(self)->str:
+        """Extracts an SBML strong from the model reference
+
+        Args:
+            self.model_ref (str): reference to the file; reference type is specified separately
+            self.ref_type (str): One of self.MODEL_self.REF_TYPES
+
+        Returns:
+            SBML string
+        """
+        if self.ref_type in [SBML_FILE, ANT_FILE]:
+            with open(self.model_ref, "r") as f:
+                lines = f.read()
+            if self.ref_type == SBML_FILE:
+                sbml_str = lines
+            else:
+                sbml_str = te.antimonyToSBML(lines)
+        elif self.ref_type == SBML_STR:
+            sbml_str = self.model_ref
+        elif self.ref_type == ANT_STR:
+            sbml_str = te.antimonyToSBML(self.model_ref)
+        elif self.ref_type == MODEL_ID:
+            # self.model_ref is the ID of a previously defined model
+            sbml_str = "" 
+        else:
+            # self.ref_type == SBML_URL
+            response = urllib3.request("GET", self.model_ref)
+            if response.status == 200:
+                sbml_str = codecs.decode(response.data, 'utf-8')
+            else:
+                raise ValueError(f"Failed to fetch SBML from URL: {self.model_ref}")
+        return sbml_str
+
+    def __str__(self):
+        params = ", ".join(f"{param} = {val}" for param, val in self.param_change_dct.items())
+        if len(params) > 0:
+            params = f" with {params}"
+        if self.ref_type == MODEL_ID:
+            source = self.id
+        else:
+            source = f'"{self.model_source_path}"'
+        return f'{self.id} = model {source} {params}'
+
+    @staticmethod 
+    def findReferenceType(model_ref:str, model_ids:List[str], ref_type:Optional[str]=None)->str:
+        """Infers the reference type from the model reference.
+
+        Args:
+            model_ref (str): reference to the file; reference type is specified separately
+            model_ids (List[str]): List of known model IDs
+            refer_type (str): One of self.MODEL_REF_TYPES
+
+        Returns:
+            str: reference type
+        """
+        # Use the ref_type if it is specified
+        if ref_type is not None:
+            return ref_type
+        # Check if this is a model ID
+        if model_ref in model_ids:
+            try:
+                is_file = os.path.exists(model_ref)
+            except:
+                is_file = False
+            if is_file:
+                warnings.warn(f"Model ID {model_ref} is also a file path. Using model ID.")
+            return MODEL_ID
+        # Check for Antimony string
+        try:
+            _ = te.loada(model_ref)
+            return ANT_STR
+        except:
+            pass
+        # Check for SBML string
+        try:
+            _ = te.loadSBMLModel(model_ref)
+            if "sbml" in model_ref:
+                return SBML_STR
+        except:
+            pass
+        # Check if this is a URL
+        if ("http://" in model_ref) or ("https://" in model_ref):
+            return SBML_URL
+        # Check if this is a file path
+        try:
+            is_file = os.path.exists(model_ref)
+        except:
+            is_file = False
+        if is_file:
+            try:
+                with open(model_ref, "r") as f:
+                    lines = f.read()
+                if lines.startswith("<"):
+                    return SBML_FILE
+                else:
+                    return ANT_FILE
+            except:
+                pass
+        # Report error
+        msg = f"Unidentifiable model reference: {model_ref}. "
+        msg += f"\nFix the reference and/or specify the reference type.\nMust be one of {MODEL_REF_TYPES}."
+        raise ValueError(msg)

plot.py

@@ -0,0 +1,41 @@
+from typing import Optional, List, Union
+
+class Plot:
+    def __init__(self, x_var:str, y_var:Union[str, List[str]], z_var:Optional[str]=None, title:Optional[str]=None,
+                 is_plot:bool=True)->None:  
+        """
+        Plot class to represent a plot in the script. The following cases are supported:
+           plot x vs y (z is None, y is str)
+           plot x vs y1, y2, y3 (z is None, y is a list of str)
+           plot x vs y vs z  (z is a str, y is str)
+
+        Args:
+            x_var (str): x variable
+            y_var (str): y variable
+            z_var (str, optional): z variable. Defaults to None.
+            title (str, optional): title of the plot. Defaults to None.
+        """
+        self.x_var = x_var
+        self.y_var = y_var
+        self.z_var = z_var
+        self.title = title
+        self.is_plot = is_plot
+
+    # FIXME: Support the above use cases 
+    def __str__(self)->str:
+        if not self.is_plot:
+            return ""
+        if self.z_var is None:
+            if isinstance(self.y_var, str):
+                y_vars = [self.y_var]
+            else:
+                y_vars = self.y_var
+            var_clause = f'{self.x_var} vs {", ".join(y_vars)}'
+        else:
+            if not isinstance(self.y_var, str):
+                raise ValueError("y_var must be a string when z_var is provided")
+            var_clause = f"{self.x_var} vs {self.y_var} vs {self.z_var}"
+        if self.title is None:
+            return f"plot {var_clause}"
+        else:
+            return f"plot \"{self.title}\" {var_clause}"

report.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+class Report:
+    def __init__(self, metadata:Optional[dict]=None, title:str=""):
+        """Reports data after a simulation.
+
+        Args:
+            metadata (Optional[dict], optional): A dictionary of values saved in the
+                'attrs' attribute of the DataFrame generated.
+            title (str, optional): Saved in the SEDML
+        """
+        self.metadata = metadata
+        self.title = title
+        self.variables:list = []
+
+    def addVariables(self, *args):
+        """
+        List of data to report
+
+        Args:
+            *args: list of report variables
+        """
+        self.variables.extend(args)
+
+    def __str__(self)->str:
+        return "\n".join([f'report "{self.title}" {", ".join(self.variables)}'])

simple_sedml.py

@@ -0,0 +1,390 @@
+from src.model import Model, ANT_STR
+from src.simulation import Simulation
+from src.task import Task, RepeatedTask
+from plot import Plot
+from src.report import Report
+
+from collections import namedtuple
+import pandas as pd # type: ignore
+import phrasedml # type: ignore
+import tellurium as te  # type: ignore
+import warnings
+from typing import Optional, List, Tuple, Union
+
+REPORT = "report"
+MODEL = "model"
+SIMULATION = "simulation"
+TASK = "task"
+REPEATED_TASK = "repeated_task"
+PLOT2D = "plot2d"
+TIME_COURSE = "time_course"
+# Simulation parameters
+ST_UNIFORM = "uniform"
+ST_STEADY_STATE = "steady_state"
+ST_UNIFORM_STOCHASTIC = "uniform_stochastic"
+# Default values
+D_START = 0
+D_END = 5
+D_NUM_STEP = 10
+D_NUM_POINT = D_NUM_STEP + 1
+D_REF_TYPE = ANT_STR
+D_SIM_TYPE  = ST_UNIFORM
+D_SIM_UNIFORM_ALGORITHM = "CVODE"
+D_SIM_UNIFORM_STOCHASTIC_ALGORITHM = "gillespie"
+
+ModelInfo = namedtuple("ModelInfo", ["model_id", "parameters", "floating_species"])
+
+"""
+PhraSED-ML is strctured as a series of sections, each of which specifies a Model, Simulation, Task or repeated task.
+
+A model section contains one or more references to models. Some of these may be indirect in that they reference a reference.
+A model section may contain changes to parameters, initial conditions or other model components.
+
+
+Restrictions:
+  - No local variables (because this is an API)
+  - No formulas (because this is an API and python can do this)
+"""
+
+
+class SimpleSEDML(object):
+    """A directive can consist of many sections each of which species a Model, Simulation, Task or repeated task,
+    and an action (plot or report).
+
+    Args:
+        object (_type_): _description_
+    """
+    def __init__(self)->None:
+        # Dictionary of script elements, indexed by their section ID
+        self.model_dct:dict = {}
+        self.simulation_dct:dict = {}
+        self.task_dct:dict = {}
+        self.repeated_task_dct:dict = {}
+        self.report_dct:dict = {}
+        self.plot_dct:dict = {}
+        #
+        self.report_id = 0
+        self.plot_id = 0
+        self.time_course_id = 0
+    
+    def __str__(self)->str:
+        """Creates phrasedml string from composition of sections
+
+        Returns:
+            str: SED-ML string
+        """
+        sections = [
+            *[str(m) for m in self.model_dct.values()],
+            *[str(s) for s in self.simulation_dct.values()],
+            *[str(t) for t in self.task_dct.values()],
+            *[str(rt) for rt in self.repeated_task_dct.values()],
+            *[str(r) for r in self.report_dct.values()],
+            *[str(p) for p in self.plot_dct.values()],
+        ]
+        return "\n".join(sections)
+    
+    def antimonyToSBML(antimony_str)->str:
+        """Converts an Antimony string to SBML
+
+        Args:
+            antimony_str: Antimony string
+
+        Returns:
+            str: SBML string
+        """
+        return te.antimonyToSBML(antimony_str)
+
+    def getSEDML(self)->str:
+        """Converts the script to a SED-ML string
+
+        Returns:
+            str: SED-ML string
+        Raises:
+            ValueError: if the conversion failsk
+        """
+        sedml_str = phrasedml.convertString(str(self))
+        if sedml_str is None:
+            raise ValueError(phrasedml.getLastError())
+        return sedml_str
+    
+    def _checkDuplicate(self, id:str, dict_type:str):
+        """Checks if the ID already exists in the dictionary
+
+        Args:
+            id: ID of the model
+            dict_type: type of the dictionary (model, simulation, task, repeated_task)
+
+        Raises:
+            ValueError: if the ID already exists in the dictionary
+        """
+        TYPE_DCT = {
+            MODEL: self.model_dct,
+            SIMULATION: self.simulation_dct,
+            TASK: self.task_dct,
+            REPEATED_TASK: self.repeated_task_dct,
+            REPORT: self.report_dct,
+            PLOT2D: self.plot_dct,
+        }
+        if id in TYPE_DCT[dict_type]:
+            raise ValueError(f"Duplicate {dict_type} ID: {id}")
+
+    def addModel(self, id:str, model_ref:str, ref_type:Optional[str]=None,
+          model_source_path:Optional[str]=None, is_overwrite:bool=False, **parameters):
+        """Adds a model to the script
+
+        Args:
+            id: ID of the model
+            model_ref: reference to the model
+            ref_type: type of the reference (e.g. "sbml_str", "ant_str", "sbml_file", "ant_file", "sbml_url")
+            model_source_path: path to the model source file
+            is_overwrite: if True, overwrite the model if it already exists
+        """
+        self._checkDuplicate(id, MODEL)
+        model_ids = list(self.model_dct.keys())
+        ref_type = Model.findReferenceType(model_ref, model_ids, ref_type=ref_type)
+        model = Model(id, model_ref, ref_type=ref_type,
+              model_source=model_source_path, is_overwrite=is_overwrite, **parameters)
+        self.model_dct[id] = model
+
+    def addSimulation(self,
+                      id:str,
+                      simulation_type:str=ST_UNIFORM,
+                      start:float=D_START,
+                      end:float=D_END,
+                      num_step:Optional[int]=None,
+                      num_point:Optional[int]=None,
+                      algorithm:Optional[str]=None): 
+        """Adds a simulation to the script
+
+        Args:
+            id (str): Simulation identifier
+            start (float): start time for simulation
+            end (float): end time for simulation 
+        """
+        if (num_step is None) and (num_point is None):
+            num_step = D_NUM_STEP
+        elif (num_step is None) and (num_point is not None):
+            num_step = num_point - 1
+        if algorithm is None:
+            if simulation_type == ST_UNIFORM:
+                algorithm = D_SIM_UNIFORM_ALGORITHM
+            elif simulation_type == ST_UNIFORM_STOCHASTIC:
+                algorithm = D_SIM_UNIFORM_STOCHASTIC_ALGORITHM
+        self._checkDuplicate(id, SIMULATION)
+        self.simulation_dct[id] = Simulation(id, simulation_type, start, end,
+              num_step, algorithm=algorithm)  # type: ignore
+
+    def addTask(self, id, model_id:str, simulation_id:str):
+        """Adds a task to the script
+
+        Args:
+            id: ID of the task
+            model: Model object
+            simulation: Simulation object
+        """
+        self._checkDuplicate(id, TASK)
+        task = Task(id, model_id, simulation_id)
+        self.task_dct[id] = task
+
+    def addRepeatedTask(self, id:str, subtask_id:str, parameter_df:pd.DataFrame, reset:bool=True):
+        """Adds a repeated task to the script
+
+        Args:
+            repeated_task: RepeatedTask object
+        """
+        self._checkDuplicate(id, REPEATED_TASK)
+        task = RepeatedTask(id, subtask_id, parameter_df, reset=reset)
+        self.repeated_task_dct[id] = task
+
+    def addPlot(self, x_var:str, y_var:Union[str, List[str]], z_var:Optional[str]=None, title:Optional[str]=None,
+                id:Optional[str]=None,
+                is_plot:bool=True)->None:  
+        """
+        Plot class to represent a plot in the script.
+        Args:
+            x_var (str): x variable
+            y_var (str): y variable or list of y variables
+            z_var (str, optional): z variable. Defaults to None.
+            title (str, optional): title of the plot. Defaults to None.
+            id (str, optional): ID of the plot. Defaults to None.
+            is_plot (bool, optional): if True, plot the data. Defaults to True.
+        """
+        if id is None:
+            id = str(self.plot_id)
+            self.plot_id += 1
+        plot = Plot(x_var, y_var, z_var=z_var, title=title, is_plot=is_plot)
+        self.plot_dct[id] = plot
+    
+    def addReport(self, *report_variables, id:Optional[str]=None,
+          metadata:Optional[dict]=None, title:str=""):
+        """Adds data to the report
+
+        Args:
+            id: ID of the report
+            report_variable: variable to be added to the report
+            metadata: metadata for the report variable
+            title: title for the report variable
+        """
+        if id is None:
+            id = str(self.report_id)
+            self.report_id += 1
+        if not id in self.report_dct.keys():
+            if len(title) == 0:
+                title = f"Report {id}"
+            self.report_dct[id] = Report(metadata=metadata, title=title)
+        if metadata is not None:
+            self.report_dct[id].metadata = metadata
+        if title is not None:
+            self.report_dct[id].title = title
+        self.report_dct[id].addVariables(*report_variables)
+
+    def _getModelInfo(self, model_id)->ModelInfo:
+        """Returns information about model ID, parameters, floating species and fixed species.
+
+        Args:
+            model_id (str):
+
+        Returns: ModelInfo
+        """
+        if model_id not in self.model_dct:
+            raise ValueError(f"Model ID {model_id} not found.")
+        model = self.model_dct[model_id]
+        rr = te.loadSBMLModel(model.sbml_str)
+        model_info = ModelInfo(
+            model_id=model.id,
+            parameters=rr.getGlobalParameterIds(),
+            floating_species=rr.getFloatingSpeciesIds(),
+        )
+        return model_info
+    
+    def execute(self)->pd.DataFrame:
+        """Executes the script and returns the results as a DataFrame
+
+        Returns:
+            pd.DataFrame: DataFrame with the results
+        """
+        if (len(self.repeated_task_dct) > 0):
+            is_repeated_task = True
+        else:
+            is_repeated_task = False
+        if len(self.task_dct) > 1:
+            is_more_than_one_task = True
+        else:
+            is_more_than_one_task = False
+        if len(self.report_dct) > 0:
+            if is_repeated_task:
+                warnings.warn("Reports only generate data for the last repeated task.")
+            if is_more_than_one_task:
+                warnings.warn("Reports only generate data for the last task.")
+        te.executeSEDML(self.getSEDML())
+        return te.getLastReport()
+    
+    def getModelInfo(self, model_id:Optional[str]=None)->List[dict]:
+        """Returns a dictionary with the model information
+
+        Args:
+            model_id: ID of the model. If None, returns information for all models 
+
+        Returns: List of dictionaries structured as follows:
+            "task_id": str
+            "parameters": list of parameters
+            "species": list of species
+        """
+        info_dcts:list = []
+        for model in self.model_dct.values():
+            if (model_id is not None) and (model.id != model_id):
+                continue
+            model_info = self._getModelInfo(model.id)
+            info_dct = dict(
+                  model_id=model_info.model_id,
+                  parameters=model_info.parameters,
+                  floating_species=model_info.floating_species
+            ) 
+            info_dcts.append(info_dct)
+        return info_dcts
+
+    @classmethod 
+    def makeTimeCourse(cls,
+         model_ref:str,
+         ref_type:Optional[str]=None,
+         plot_variables:Optional[str]=None,
+         start:float=0, end:float=5, num_step:int=50,
+         time_course_id:Optional[str]=None,
+         title:Optional[str]=None,
+         algorithm:Optional[str]=None,
+         **parameters)->str:
+        """Creates a time course simulation
+
+        Args:
+            model_ref: reference to the model
+            ref_type: type of the reference (e.g. "sbml_str", "ant_str", "sbml_file", "ant_file", "sbml_url")
+            plot_variables: variables to be plotted
+            start: start time
+            end: end time
+            num_step: number of steps
+            time_course_id: ID of the time course simulation
+            algorithm: algorithm to use for the simulation
+            title: title of the plot
+            parameters: parameters to be passed to the model
+
+        Returns:
+            str: SEDML
+        """
+        if time_course_id is None:
+            time_course_id = TIME_COURSE
+        model_id = f"{time_course_id}_model"
+        sim_id = f"{time_course_id}_sim"
+        task_id = f"{time_course_id}_task"
+        if title is None:
+            title = ""
+        #
+        simple = cls()
+        simple.addModel(model_id, model_ref, ref_type=ref_type, is_overwrite=True, **parameters)
+        if plot_variables is None:
+            variable_dct = simple.getModelInfo(model_id)[0]
+            plot_variables = variable_dct['floating_species']
+            plot_variables.insert(0, "time")   # type: ignore
+        simple.addSimulation(sim_id, "uniform", start, end, num_step, algorithm=algorithm)
+        simple.addTask(task_id, model_id, sim_id)
+        x1_var = plot_variables[0]
+        y_vars = plot_variables[1:]
+        simple.addPlot(x1_var, y_vars, title=title)
+        return simple.getSEDML()
+    
+    def validate(self):
+        """
+        Validates the script and returns a list of errors.
+        Checks for:
+        1. At least one model is defined.
+        2. At least one simulation is defined.
+        3. At least one task is defined.
+        4. At least one output is defined.
+        5. All referenced task IDs are defined.
+        """
+        raise NotImplementedError("Validation is not implemented yet.")
+
+    @classmethod
+    def executeSEDML(cls, sedml_str:str)->Union[None, pd.DataFrame]:
+        """Executes the SED-ML string and returns the results as a DataFrame
+
+        Args:
+            sedml_str: SED-ML string
+
+        Returns:
+            pd.DataFrame: DataFrame with the results
+        """
+        try:
+            te.executeSEDML(sedml_str)
+        except Exception as e:
+            raise RuntimeError(f"SED-ML execution failed: {e}")
+        # Return a DataFrame if there is a report
+        num_report = sedml_str.count("<report id=")
+        if num_report > 1:
+            warnings.warn("Only generate data for the last report.")
+        if num_report >= 1:
+            df = te.getLastReport()
+            if df is None:
+                raise ValueError("No report found.")
+            return df
+        else:
+            return None

simplesedml-0.0.1.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: SimpleSEDML
+Version: 0.0.1
+Summary: Python Subnet Discovery for Systems Biology
+Author-email: Joseph Hellerstein <joseph.hellerstein@gmail.com>, Herbert S Sauro <hsauro@uw.edu>
+License: MIT License
+        
+        Copyright (c) 2025 UW Sauro Lab
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/sys-bio/SimpleSEDML
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: build
+Requires-Dist: coverage
+Requires-Dist: jupyterlab
+Requires-Dist: matplotlib
+Requires-Dist: nose2
+Requires-Dist: pandas
+Requires-Dist: phrasedml
+Requires-Dist: pip
+Requires-Dist: requests
+Requires-Dist: tabulate
+Requires-Dist: tellurium
+Requires-Dist: twine
+Requires-Dist: urllib3
+Dynamic: license-file
+
+[![Build](https://github.com/sys-bio/SimpleSEDML/actions/workflows/github-actions.yml/badge.svg)](https://github.com/sys-bio/SimpleSBML/actions/workflows/github-actions.yml)
+
+# SimpleSEDML
+A simple API for using the [Simulation Experiment Description Markup Language (SED-ML)](https://sed-ml.org/), a community standard for describing simulation experiments.
+
+The project provides a python interface to generating SED-ML based on the abstractions provided by [phraSED-ML](https://pmc.ncbi.nlm.nih.gov/articles/PMC5313123/pdf/nihms846540.pdf) to describe simulation experiments. These absractions are: (a) models (including changes in values of model parameters);
+(b) simulations (including deterministic, stochastic, and steady state);
+(c) tasks (which specify simulations to run on tasks and repetitions for changes in parameter values);
+and (d) output for data reports and plots.
+
+``SimpleSEDML`` generalizes the capabilities of ``PhraSEDML`` and simplifies its usage by exploiting the Python environment:
+
+* A model source can be a file path or URL and may be in the Antimony language as well as SBML;
+* Repeated tasks are defined more simply by the use of a ``pandas`` ``DataFrame``.
+* Convenience methods are provided to simplify the API.
+  
+# Example
+
+See this [Jupyter notebook](https://github.com/sys-bio/SimpleSEDML/blob/main/examples/usage_examples.ipynb) for a detailed example.
+
+Consider the model below in the Antimony language.
+
+    mymodel = """
+    model myModel
+        J1: S1 -> S2; k1*S1;
+        k1 = 0.5;
+    end
+    """
+
+We want to simulate this model and do a time course plot of all floating species in the model.
+
+    from simple_sedml import SimpleSEDML
+
+    sedml_str = SimpleSEDML.makeTimeCourse(mymodel)
+
+We can print, save, or execute ``sedml_str``. To execute it,
+
+    SimpleSEDML.executeSEDML(sedml_str)
+<img src="docs/images/phrasedml_example.png" style="width:300px;height:300px;">
+
+# Restrictions
+1. If there are multiple task directives and/or there is a repeated task directive AND there is a report directive, SimpleSEDML.execute only returns the results of the last simulation. You can circumvent this by iterating in python to obtain the desired reports.
+
+# Plans
+1. First implementation of ``SimpleSEDML`` with methods for ``addModel``, ``addSimulation``, ``addTask``, ``addReport``, ``execute``, and ``to_sedml``.

simplesedml-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+constants.py,sha256=Gko24Uw_l3rFDYmL9qEjOWZHyVul14dycoIV_BDUA-k,113
+model.py,sha256=VYKRcIYTpdfV2KpHGScp3xmAKqPu_BvtWgq1aTF4n2c,7058
+plot.py,sha256=uhVbfd7RDcjAH1_mIxIYYHXkPA8NZLxAAKnnpbDDCH0,1562
+report.py,sha256=K4VNeQE5RfJncyvjgSbZw9qU1ww0vGM1sjt3ndGZho4,771
+simple_sedml.py,sha256=YHaroiHa_vYG2MH7p6F7nIV_CD0JOtTdKaM1rcQox_o,14077
+simulation.py,sha256=0_82AVeAPGzY9vOLysrl6khHwt-abV1ofcP4nZzUCQk,3654
+task.py,sha256=XA5CLfrbbXuXumfbYcHCvecl0PtYxnYG38uOLPmc1lY,2064
+simplesedml-0.0.1.dist-info/licenses/LICENSE,sha256=vyn7B-UTdbg7Tu5NPD5FChKtwroX0n_ILQwKp3RpXGY,1069
+simplesedml-0.0.1.dist-info/METADATA,sha256=ZsCoH1XRog6Hu0dIeImskzx4_CcNYlZ-bRoc-iUv5os,4300
+simplesedml-0.0.1.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+simplesedml-0.0.1.dist-info/top_level.txt,sha256=7Yk_B53o9eR6joDkOmHrrrMr8zgi25-LP7XMmOWwELg,66
+simplesedml-0.0.1.dist-info/RECORD,,

simplesedml-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.3.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simplesedml-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 UW Sauro Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simplesedml-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,8 @@
+__init__
+constants
+model
+plot
+report
+simple_sedml
+simulation
+task

simulation.py

@@ -0,0 +1,88 @@
+'''Simulation directives for PhraSEDML'''
+
+from typing import Optional
+
+# Simulation types
+ST_UNIFORM = "uniform"
+ST_STOCHASTIC = "stochastic"
+ST_ONESTEP = "onestep"
+
+
+class Simulation:
+    def __init__(self, id:str, simulation_type:str,
+          start:float=0,
+          end:float=5,
+          num_step:int=50,
+          time_interval:float=0.5, # required for onestep
+          absolute_tolerance:Optional[float]=None,
+          algorithm:Optional[str]=None,
+          initial_time_step:Optional[float]=None,
+          maximum_adams_order:Optional[int]=None,
+          maximum_bdf_order:Optional[int]=None,
+          maximum_iterations:Optional[int]=None,
+          maximum_num_steps:Optional[int]=None,
+          maximum_time_step:Optional[float]=None,
+          minimum_damping:Optional[float]=None,
+          minimum_time_step:Optional[float]=None,
+          relative_tolerance:Optional[float]=None,
+          seed:Optional[int]=None,
+          variable_step_size:Optional[bool]=None):
+        """Simulation class for SED-ML
+        Args: 
+            id (str): identifier for the simulation
+            simulation_type (str): type of simulation
+                - "uniform": uniform simulation
+                - "stochastic": stochastic simulation
+                - "onestep": one-step simulation
+            start (float): start time for the simulation
+            end (float): end time for the simulation
+            num_step (int): number of steps for the simulation
+            time_interval (float): time interval for the simulation
+            algorithm (str): algorithm to use for the simulation. Defaults are:
+                - "CVODE": CVODE algorithm
+                - "gillespie": Gillespie algorithm
+        """
+        self.id = id
+        self.simulation_type = simulation_type
+        self.start = start
+        self.end = end
+        self.num_step = num_step
+        self.time_interval = time_interval
+        if algorithm is None:
+            if simulation_type == ST_UNIFORM:
+                algorithm = "CVODE"
+            elif simulation_type == ST_STOCHASTIC:
+                algorithm = "gillespie"
+        self.algorithm = algorithm
+        # Setup the options
+        self.option_dct =  dict(
+              absolute_tolerance=absolute_tolerance,
+              algorithm=algorithm,
+              initial_time_step=initial_time_step,
+              maximum_adams_order=maximum_adams_order,
+              maximum_bdf_order=maximum_bdf_order,
+              maximum_iterations=maximum_iterations,
+              maximum_num_steps=maximum_num_steps,
+              maximum_time_step=maximum_time_step,
+              minimum_damping=minimum_damping,
+              minimum_time_step=minimum_time_step,
+              relative_tolerance=relative_tolerance,
+              seed=seed,
+              variable_step_size=variable_step_size
+        )
+
+    def __str__(self)->str:
+        if self.simulation_type == ST_UNIFORM:
+            simulate_arg = "simulate uniform"
+        elif self.simulation_type == ST_STOCHASTIC:
+            simulate_arg = "simulate uniform_stochastic"
+        if self.simulation_type == ST_ONESTEP:
+            line = f'{self.id} = simulate onestep({self.time_interval})'
+        else:
+            line = f'{self.id} = {simulate_arg}({self.start}, {self.end}, {self.num_step})'
+        # Include the options
+        option_lines = [f"{self.id}.algorithm.{k} = {str(v)} " for k, v in self.option_dct.items() 
+              if (v is not None) and (k != "algorithm")]
+        option_lines.append(f"{self.id}.algorithm = {self.algorithm}")
+        section = line + "\n" + "\n".join(option_lines)
+        return section

task.py

@@ -0,0 +1,57 @@
+from src.model import Model
+from src.simulation import Simulation
+
+import pandas as pd; # type: ignore
+from typing import List
+
+
+class Task:
+    def __init__(self, id:str, model_id:str, simulation_id:str):
+        self.id = id
+        self.model_id = model_id
+        self.simulation_id = simulation_id
+
+    def __str__(self)->str:
+        result = f'{self.id} = run {self.simulation_id} on {self.model_id}'
+        return result
+
+
+class RepeatedTask:
+    # A RepeatedTask executes a task with changes in the values of global parameters.
+    # Ex: repeat1 = repeat nested_task for S1 in [1, 3, 5], S2 in [0, 10, 3], reset=true
+    # Note that it is not necessary to specify functions as in the original phraSED-ML since python provides this.
+
+    def __init__(self, id:str, subtask_id:str, parameter_df:pd.DataFrame, reset:bool=True):
+        """Repeats a single task with changes in global parameters.
+
+        Args:
+            id (str): Identity of repeated task
+            subtask_id (Task): Task to be repeated
+            parameter_df (pd.DataFrame): DataFrame with the parameters to be changed. Column names must be global parameters.
+            reset (bool, optional): _description_. Defaults to True.
+        """
+        #
+        self.id = id
+        self.subtask_id = subtask_id
+        self.parameter_df = parameter_df
+        self.reset = reset
+
+    def _makeChangeValues(self)->str:
+        """Creates a string with the changes in the values of global parameters.
+
+        Args:
+            ser (pd.Series): Series with the changes in the values of global parameters.
+
+        Returns:
+            str: String with the changes in the values of global parameters.
+        """
+        results = []
+        for col in self.parameter_df.columns:
+            results.append(f'{col} in {str(list(self.parameter_df[col].values))}')
+        return ', '.join(results)
+
+    def __str__(self)->str:
+        line = f'{self.id} = repeat {self.subtask_id} for '
+        line += self._makeChangeValues()
+        line += f', reset={self.reset}'
+        return line