cdFBA 0.0.1__tar.gz

cdfba-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vivarium Collective
+
+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.

cdfba-0.0.1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.2
+Name: cdFBA
+Version: 0.0.1
+Home-page: https://github.com/vivarium-collective/cdFBA
+Author: Tasnif Rahman
+Author-email: trahman@uchc.edu
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: vivarium-interface
+Requires-Dist: cobra
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# cdFBA
+Community Dynamic Flux Balance Analysis using process-bigraph. 
+
+
+#### This project is a work in progress

cdfba-0.0.1/README.md

@@ -0,0 +1,5 @@
+# cdFBA
+Community Dynamic Flux Balance Analysis using process-bigraph. 
+
+
+#### This project is a work in progress

cdfba-0.0.1/cdFBA/__init__.py

@@ -0,0 +1,71 @@
+from cdFBA.processes import register_processes
+
+def apply_non_negative(schema, current, update, core):
+    new_value = current + update
+    return max(0, new_value)
+
+
+def set_update(schema, current, update, core):
+    return update
+
+def volumetric_update(schema, current, update, core):
+    counts = update.get('counts')
+    volume = current.get('volume')
+
+    new_counts = current['counts']
+    new_concentrations = current['concentrations']
+    if counts:
+        for key, value in counts.items():
+            new = new_counts[key] + value
+            new_counts[key] = new
+            new_concentrations[key] = new/volume
+
+    return {
+        'counts': new_counts,
+        'concentrations': new_concentrations,
+        'volume': volume,
+    }
+
+positive_float = {
+    '_type': 'positive_float',
+    '_inherit': 'float',
+    '_apply': apply_non_negative}
+
+set_float = {
+    '_type': 'set_float',
+    '_inherit': 'float',
+    '_apply': set_update
+}
+
+bounds_type = {
+    'lower': 'maybe[float]',
+    'upper': 'maybe[float]'}
+
+
+particle_type = {
+    'id': 'string',
+    'position': 'tuple[float,float]',
+    'size': 'float',
+    'local': 'map[float]',
+    'exchange': 'map[float]',    # {mol_id: delta_value}
+}
+
+volumetric_type = {
+    'concentrations':'map[float]',
+    'counts':'map[float]',
+    'volume': 'float',
+    '_apply': volumetric_update
+}
+
+chemostat_type = {
+    'concentration': 'float'
+}
+
+def register_types(core):
+    core.register('positive_float', positive_float)
+    core.register('set_float', set_float)
+    core.register('bounds', bounds_type)
+    core.register('particle', particle_type)
+    core.register('volumetric', volumetric_type)
+    
+    return register_processes(core)

cdfba-0.0.1/cdFBA/processes/__init__.py

@@ -0,0 +1,6 @@
+from cdFBA.processes.dfba import DFBA
+
+def register_processes(core):
+    core.register_process('DFBA', DFBA)
+    
+    return core

cdfba-0.0.1/cdFBA/processes/dfba.py

@@ -0,0 +1,363 @@
+import random
+import pprint
+import math
+
+from process_bigraph.composite import ProcessTypes
+from process_bigraph import Process, Step, Composite
+
+from cdFBA.utils import model_from_file, get_objective_reaction, get_injector_spec, get_wave_spec, get_chemo_spec
+from cdFBA.utils import get_single_dfba_spec, dfba_config, environment_spec, initial_environment
+
+from matplotlib import pyplot as plt
+
+
+class DFBA(Process):
+    """Performs single time-step of dynamic FBA
+
+    Parameters:
+    -----------
+    model_file: string, math to cobra model file
+    """
+    config_schema = {
+        "model_file": {
+            '_type': 'string',
+            '_default': 'iAF1260',
+        },
+        "name": 'string',
+        "kinetics": "any",
+        "reaction_map": "any",
+        "biomass_identifier": "any",
+        "bounds": "maybe[map[bounds]]",
+    }
+
+    def __init__(self, config, core):
+        super().__init__(config, core)
+
+        # TODO -- load model here rather than passing it in
+        self.model = model_from_file(self.config['model_file'])
+
+
+        if self.config["bounds"] is not None:
+            if len(self.config["bounds"]) != 0:
+                for reaction_id, bounds in self.config["bounds"].items():
+                    if bounds["lower"] is not None:
+                        self.model.reactions.get_by_id(reaction_id).lower_bound = bounds["lower"]
+                    if bounds["upper"] is not None:
+                        self.model.reactions.get_by_id(reaction_id).upper_bound = bounds["upper"]
+
+    # def initial_state(self):
+    #     # TODO -- get the initial state from the load model, self.model
+    #     return {
+    #         "dfba_update": {
+    #             'Biomass_Ecoli_core': 0,
+    #             'acetate': 0,
+    #             'glucose': 0}}
+
+    def inputs(self):
+        return {
+            "shared_environment": "volumetric", #initial conditions for time-step
+            "current_update": "map[map[set_float]]",
+        }
+
+    def outputs(self):
+        return {
+             "dfba_update": "map[set_float]"
+        }
+
+
+    def update(self, inputs, interval):
+        current_state = {key:inputs["shared_environment"]["counts"][key] for key, value in self.config["reaction_map"].items()}
+        current_state[self.config["name"]] = inputs["shared_environment"]["counts"][self.config["name"]]
+        state_update = current_state.copy()
+
+        for substrate_id, reaction_id in self.config["reaction_map"].items():
+            Km, Vmax = self.config["kinetics"][substrate_id]
+            substrate_concentration = inputs["shared_environment"]["concentrations"][substrate_id]
+
+            # calculate michaelis-menten flux
+            flux = Vmax * substrate_concentration / (Km + substrate_concentration)
+
+            # use the flux to constrain fba
+            self.model.reactions.get_by_id(reaction_id).lower_bound = -flux
+
+        # solve fba under these constraints
+        solution = self.model.optimize()
+
+        # gather the results
+        ## update biomass
+        biomass_growth_rate = solution.fluxes[self.config["biomass_identifier"]]
+        current_biomass = current_state[self.config["name"]]
+        state_update[self.config['name']] = biomass_growth_rate * current_biomass * interval
+
+        ## update substrates
+        for substrate_id, reaction_id in self.config["reaction_map"].items():
+            flux = solution.fluxes[reaction_id]
+            state_update[substrate_id] = (flux * current_biomass * interval)
+
+        return {"dfba_update": state_update}
+
+class UpdateEnvironment(Step): #TODO =:
+    config_schema = {}
+
+    def __init__(self, config, core):
+        super().__init__(config, core)
+
+    def inputs(self):
+        return {
+             "shared_environment": "volumetric",
+             "species_updates": "map[map[set_float]]" #TODO add a species_update type
+        }
+
+    def outputs(self):
+        return {
+            "shared_environment": "map[float]",
+        }
+
+    def update(self, inputs):
+        species_updates = inputs["species_updates"]
+        shared_environment = inputs["shared_environment"]["counts"]
+        env_volume = inputs["shared_environment"]["volume"]
+
+        species_list = [species for species in species_updates]
+        random.shuffle(species_list)
+
+        update = shared_environment.copy()
+
+        for species in species_list:
+            for substrate_id in species_updates[species]:
+                if (shared_environment[substrate_id] + species_updates[species][substrate_id]) > 0:
+                    update[substrate_id] = species_updates[species][substrate_id]
+                else:
+                    update[substrate_id] = -shared_environment[substrate_id]
+
+        return {
+            "shared_environment": {'counts': update}
+        }
+
+class Chemostat(Process):
+    """The Chemostat process maintains the concentration of given substrates at a fixed value at each time-step
+    """
+    config_schema = {
+        "substrate_concentrations" : "map[float]",
+    }
+
+    def __init__(self, config, core):
+        super().__init__(config, core)
+
+    def inputs(self):
+        return {
+            "shared_environment": "volumetric",
+            "global_time": "float"
+        }
+
+    def outputs(self):
+        return {
+            "shared_environment": "map[float]"
+        }
+
+    def update(self, inputs, interval):
+        shared_environment = inputs["shared_environment"]["counts"]
+
+        update = {}
+
+        for substrate, values in self.config["substrate_concentrations"].items():
+            update[substrate] = (values * inputs["shared_environment"]["volume"]) - shared_environment[substrate]
+
+        return {
+            "shared_environment": {'counts': update}
+        }
+
+class WaveFunction(Process):
+    """The WaveFunction process maintains the concentration of given substrates based on a wave-function
+    """
+    config_schema = {
+        "substrate_params" : "map[map[float]]",
+    }
+
+    """
+    substrate_params = {
+        "substrate_name": {
+            "amplitude": "float",
+            "angular_frequency": "float",
+            "base_concentration": "float",
+            "phase_shift": "float"
+        }
+    }
+    
+    amplitude : float, amplitude of wave function
+    angular_frequency : float, angular frequency of wave function
+    base_concentration : float, base concentration substrate
+    phase_shift : float, phase shift of wave function (when wave starts)
+    """
+
+    def __init__(self, config, core):
+        super().__init__(config, core)
+
+    def inputs(self):
+        return {
+            "shared_environment": "volumetric",
+            "global_time": "float"
+        }
+
+    def outputs(self):
+        return {
+            "shared_environment": "map[float]"
+        }
+
+    def update(self, inputs, interval):
+        shared_environment = inputs["shared_environment"]["counts"]
+        t = inputs["global_time"]
+        update = {}
+        for substrate in self.config["substrate_params"]:
+            A = self.config["substrate_params"][substrate]["amplitude"]
+            w = self.config["substrate_params"][substrate]["angular_frequency"]
+            B = self.config["substrate_params"][substrate]["base_concentration"]
+            phi = self.config["substrate_params"][substrate]["phase_shift"]
+
+            current_count = (A*math.sin(w*t+phi) + B) * inputs["shared_environment"]["volume"]
+
+            update[substrate] = (current_count - shared_environment[substrate])
+
+        return {
+            "shared_environment": {'counts': update}
+        }
+
+class Injector(Process):
+    """The Injector process injects a given amount of a given substrate at regular intervals into the shared environment
+    """
+    config_schema = {
+        "injection_params" : "map[map[float]]",
+    }
+
+    # injection_params = {
+    #     "substrate_name" : {
+    #         "amount": "float",
+    #         "interval": "float",
+    #     }
+    # }
+
+    def __init__(self, config, core):
+        super().__init__(config, core)
+
+    def inputs(self):
+        return {
+            "shared_environment": "volumetric",
+            "global_time": "float"
+        }
+
+    def outputs(self):
+        return {
+            "shared_environment": "map[float]"
+        }
+
+    def update(self, inputs, interval):
+        shared_environment = inputs["shared_environment"]["counts"]
+        t = inputs["global_time"]
+        update = {}
+        for substrate in self.config["injection_params"]:
+            if ((t % self.config["injection_params"][substrate]["interval"]) == 0) & (t!=0.0):
+                update[substrate] = self.config["injection_params"][substrate]["amount"]
+        return {
+            "shared_environment": {'counts': update}
+        }
+
+def run_environment(core):
+    """This tests that the environment runs"""
+    name1 = "E.coli"
+    name2 = "S.flexneri"
+    # define a single dFBA model
+    spec = {
+        name1: get_single_dfba_spec(model_file= "iAF1260", name=name1)
+    }
+
+    spec[name2] = get_single_dfba_spec(model_file = "iSFxv_1172", name=name2)
+
+    spec['shared environment'] = initial_environment(volume=2, species_list=[name1, name2])
+
+    spec['dFBA Results'] = {name1:
+        {
+            "glucose": 0,
+            "acetate": 0,
+            spec[name1]['config']['name']: 0,
+        },
+        name2:
+        {
+            "glucose": 0,
+            "acetate": 0,
+            spec[name2]['config']['name']: 0,
+        }
+    }
+
+    spec['update environment'] = environment_spec()
+
+    injector_config = {
+        "injection_params": {
+            "glucose": {
+                "amount": 80,
+                "interval": 5,
+            }
+        }
+    }
+
+    spec['environment dynamics'] = get_injector_spec(config=injector_config)
+
+    pprint.pprint(spec)
+
+    # put it in a composite
+    sim = Composite({
+        "state": spec,
+        "emitter": {'mode': 'all'}},
+        core=core
+    )
+
+    # run the simulation
+    sim.run(40)
+    results = sim.gather_results()[('emitter',)]
+
+    # print the results
+    timepoints = []
+    for timepoint in results:
+        time = timepoint.pop('global_time')
+        timepoints.append(time)
+        dfba_spec = timepoint.pop(name1)
+        print(f'TIME: {time}')
+        print(f'STATE: {timepoint}')
+
+    env = [timepoint['shared environment']['concentrations'] for timepoint in results]
+    env_combined = {}
+    for d in env:
+        for key, value in d.items():
+            if key not in env_combined:
+                env_combined[key] = []
+            env_combined[key].append(value)
+
+
+    fig, ax = plt.subplots(dpi=300)
+    for key, value in env_combined.items():
+        # if not key == 'glucose':
+        #     continue
+        ax.plot(timepoints, env_combined[key], label=key)
+    plt.xlabel('Time')
+    plt.ylabel('Substrate Concentration')
+    plt.legend()
+    plt.tight_layout()
+    plt.show()
+
+if __name__ == "__main__":
+    from cdFBA import register_types
+
+    # create a core
+    core = ProcessTypes()
+    core = register_types(core)
+
+    core.register_process('DFBA', DFBA)
+    core.register_process('UpdateEnvironment', UpdateEnvironment)
+    core.register_process('Chemostat', Chemostat)
+    core.register_process('WaveFunction', WaveFunction)
+    core.register_process('Injector', Injector)
+
+    # print(get_single_dfba_spec())
+    # test_dfba_alone(core)
+    # test_dfba(core)
+    run_environment(core)
+    # test_composite()

cdfba-0.0.1/cdFBA/utils.py

@@ -0,0 +1,478 @@
+"""This module contains some methods to obtain the reaction map, initial conditions, and kinetic parameters needed
+for dFBA simulations from the minimal medium requirements of the wild-type species.
+
+CAUTION: The initial conditions, and kinetics dataframes provide default parameter values and must be changed as needed
+CAUTION: Substrate names are different in BiGG and AGORA databases. These functions will not work with two models form
+         different sources
+"""
+from cobra.io import load_model, read_sbml_model, load_json_model, load_yaml_model, load_matlab_model
+from cobra.medium import minimal_medium
+import pprint
+import re
+
+#single species functions
+def model_from_file(model_file='textbook'):
+    """Returns a cobra model from a model file path or BiGG Model ID
+    Parameters:
+        model_file: str, file path or BiGG Model ID
+    Returns:
+        model: cobra model
+    """
+    if ".xml" in model_file:
+        model = read_sbml_model(model_file)
+    elif ".json" in model_file:
+        model = load_json_model(model_file)
+    elif ".yaml" in model_file:
+        model = load_yaml_model(model_file)
+    elif ".mat" in model_file:
+        model = load_matlab_model(model_file)
+    elif isinstance(model_file, str):
+        model = load_model(model_file)
+    else:
+        # error handling
+        raise ValueError("Invalid model file")
+    return model
+
+def get_exchanges(model_file='textbook', medium_type='exchange'):
+    """
+
+    Parameters:
+        model_file: str, file path or BiGG Model ID
+        medium_type:
+            'default' uses the default cobra model medium
+            'minimal' uses the minimal medium for the model
+            'exchange' uses all exchange fluxes for the model
+            defaults to 'exchange'
+    Returns:
+        exchanges: list of exchange reaction IDs
+    """
+    model=model_from_file(model_file)
+    if medium_type == 'default':
+        medium = model.medium
+    if medium_type == 'minimal':
+        medium = minimal_medium(model, model.slim_optimize()).to_dict()
+    if medium_type == 'exchange':
+        medium = {reaction.id: reaction.upper_bound for reaction in model.exchanges}
+        medium.update(model.medium)
+        medium = medium
+    return list(medium.keys())
+
+def get_substrates(model_file='textbook', exchanges=None):
+    """Returns a list of substrates from the model.
+    Parameters:
+    model_file : str, file path or BiGG Model ID
+    exchanges : lst, a list of exchange reaction ids
+    Returns:
+    substrates : lst, list of names of substrates required by the model organism
+    """
+    if exchanges is None:
+        exchanges = get_exchanges(model_file)
+    model = model_from_file(model_file)
+    substrates = []
+
+    for item in [getattr(model.reactions, i).name for i in exchanges if hasattr(model.reactions, i)]:
+
+        match = re.match(r"(.*) exchange|exchange reaction for (.*)|Exchange of (.*)|echange reaction for (.*)", item, re.IGNORECASE)
+
+        if match:
+            substrates.append(match.group(1) or match.group(2) or match.group(3) or match.group(4))
+        else:
+            substrates.append(item)
+    return substrates
+        
+def get_reaction_map(model_file='textbook', exchanges=None):
+    """Returns a reaction_name_map dictionary from a medium dictionary as obtained
+    from model.medium or cobra.medium.minimum_medium()
+    Parameters:
+        model_file : str, file path or BiGG Model ID
+        exchanges : lst, list of names of substrates required by the model organism
+    Returns:
+        reaction_name_map : dict, maps substrate names to reactions
+    """
+    if exchanges is None:
+        exchanges = get_exchanges(model_file)
+    model = model_from_file(model_file)
+    substrates = get_substrates(model_file, exchanges)
+    ids = exchanges
+    reaction_name_map = {}
+    for i in range(len(substrates)):
+        reaction_name_map[substrates[i]] = ids[i]
+    return reaction_name_map
+    
+def get_kinetics(model_file='textbook', exchanges=None):
+    """Returns default kinetic parameters dictionary. Values are tuples of the form (km, vmax)
+    Parameters:
+        model_file : str, file path or BiGG Model ID
+        exchanges : lst, list of exchange reaction ids
+    """
+    if exchanges is None:
+        exchanges = get_exchanges(model_file)
+    model = model_from_file(model_file)
+    kinetics = {key: (0.5, 2.0) for key in get_substrates(model_file, exchanges)}
+    return kinetics
+
+def get_bounds(reaction_map, upper=1000, lower=-1000):
+    """Return dict of default upper and lower bounds for each substrate exchange reaction
+    Parameters:
+        reaction_map : dict, maps substrate names to reactions
+        upper : float, upper bound, default 1000
+        lower : float, lower bound, default -1000
+    Returns:
+        bounds : dict, default bounds for all exchange reactions
+    """
+    return {reaction_map[key]: {'lower': lower, 'upper': upper} for key in reaction_map.keys()}
+
+def get_objective_reaction(model_file = 'textbook'):
+    """get a string with the name of the objective function of a cobra model
+    Parameters:
+        model: cobrapy model
+    Returns:
+        objective_reaction: str, name of the objective reaction (biomass reaction by default)
+    """
+    model = model_from_file(model_file)
+    expression = f"{model.objective.expression}"
+    match = re.search(r'1\.0\*([^\s]+)', expression)
+
+    if match:
+        objective_reaction = match.group(1)
+
+    return objective_reaction
+
+def dfba_config(
+        model_file="textbook",
+        name=None,
+        kinetics=None,
+        reaction_map=None,
+        biomass_identifier=None,
+        bounds=None
+):
+    """Construct a configuration dictionary for a single cobra model
+    Parameters:
+        model_file: str, file path or BiGG Model ID
+        name: str, name of the process
+        kinetics: dict, kinetic parameters for shared substrates
+        reaction_map: dict, maps substrate names to reaction ids
+        biomass_identifier: str, name of the biomass reaction
+        bounds: dict, bounds for exchange reactions
+    Returns:
+        config: dict, config dictionary for a single species dFBA
+    """
+    model = model_from_file(model_file)
+    if name is None:
+        name = model.id
+    if reaction_map is None:
+        reaction_map = {
+            "glucose": "EX_glc__D_e",
+            "acetate": "EX_ac_e"
+        }
+    if bounds is None:
+        bounds = {
+            "EX_o2_e": {"lower": -2, "upper": None},
+            "ATPM": {"lower": 1, "upper": 1}
+        }
+    if kinetics is None:
+        kinetics = {
+            "glucose": (0.02, 15),
+            "acetate": (0.5, 7)}
+    if biomass_identifier is None:
+        biomass_identifier = get_objective_reaction(model_file=model_file)
+
+    return {
+        "model_file": model_file,
+        "name": name,
+        "kinetics": kinetics,
+        "reaction_map": reaction_map,
+        "biomass_identifier": biomass_identifier,
+        "bounds": bounds,
+    }
+
+def get_single_dfba_spec(
+        model_file="textbook",
+        name="species",
+        config=None,
+        interval=1.0
+):
+    """Constructs a configuration dictionary for a dynamic FBA process
+    Parameters:
+        model_file: str, file path or BiGG Model ID
+        name: str, identifier for the model, usually species/strain name
+        config: dict, config for DFBA Process. If none provided, uses default generated using `dfba_config()`
+        interval: float, interval between consecutive dFBA calculations
+    Returns:
+        dict: dict, specification dictionary for a single species dFBA
+    """
+
+    if config is None:
+        config = dfba_config(model_file=model_file, name=name)
+
+    return {
+        "_type": "process",
+        "address": "local:DFBA",
+        "config": config,
+        "inputs": {
+            "shared_environment": ["shared environment"],
+            "current_update": ["dFBA Results"]
+        },
+        "outputs": {
+            "dfba_update": ["dFBA Results", name]
+        },
+        "interval": interval
+    }
+
+#multi-species functions
+def make_cdfba_composite(model_dict, medium_type=None, exchanges=None, volume=1, interval=1.0):
+    """Construct a cdfba composite spec with all exhange metabolites included.
+    Parameters:
+        model_dict : dict, dictionary with cdfba process names as keys and model name/path as values
+        medium_type : str/lst, if str, pick one of:
+            'default' uses the default cobra model medium
+            'minimal' uses the minimal medium for the model
+            'exchange' uses all exchange fluxes for the model
+            MUST be None if exchanges is provided
+        exchanges: a list of exchange reaction ids. MUST be None if medium_type is provided
+        volume: float, volume of cdfba composite
+        interval: float, interval between consecutive dFBA calculations
+    Returns:
+        spec : dict, cdfba composite spec
+    """
+    spec = {'dFBA Results': {}}
+    if medium_type is None:
+        if exchanges is None:
+            raise ValueError("Must provide medium_type or exchanges list")
+
+    if medium_type is not None:
+        if exchanges is not None:
+            raise ValueError("Provide only on of medium_type or exchanges list")
+
+    if exchanges is None:
+        env_exchanges = []
+        for name, model_file in model_dict.items():
+            env_exchanges.extend(get_exchanges(model_file=model_file, medium_type=medium_type))
+
+        env_exchanges = list(set(env_exchanges))
+    else:
+        env_exchanges = exchanges
+
+    initial_counts = get_initial_counts(model_dict, exchanges=env_exchanges)
+    initial_env = initial_environment(volume=volume, initial_counts=initial_counts, species_list=model_dict.keys())
+    spec['shared environment'] = initial_env
+
+    for model_name, model_file in model_dict.items():
+        if exchanges is None:
+            model_exchanges = get_exchanges(model_file=model_file, medium_type=medium_type)
+        else:
+            model_exchanges = exchanges
+        substrates = get_substrates(model_file=model_file, exchanges=model_exchanges)
+        kinetics = get_kinetics(model_file=model_file, exchanges=model_exchanges)
+        reaction_map = get_reaction_map(model_file=model_file, exchanges=model_exchanges)
+        biomass_identifier = get_objective_reaction(model_file=model_file)
+        bounds = {}
+
+        config = dfba_config(
+            model_file=model_file,
+            name=model_name,
+            kinetics=kinetics,
+            reaction_map=reaction_map,
+            biomass_identifier=biomass_identifier,
+            bounds=bounds
+        )
+        model_spec = get_single_dfba_spec(model_file=model_file, name=model_name, config=config, interval=interval)
+        spec[model_name] = model_spec
+
+        spec['dFBA Results'][model_name] = {substrate: 0 for substrate in substrates}
+        spec['dFBA Results'][model_name].update({model_name: 0})
+    spec['update environment'] = environment_spec()
+    return spec
+
+def get_initial_counts(model_dict, biomass=0.5, initial_value=20, exchanges=None):
+    """Returns an initial condition dict based on medium
+    Parameters:
+        model_dict: dict, dictionary with cdfba process names as keys and model name/path as values
+        biomass : float, initial biomass for all species
+        initial_value : float, initial counts of all species
+        exchanges: lst, list of exchange reaction ids
+    Returns:
+        conditions : dict, initial conditions dictionary
+    """
+    all_substrates = []
+    for model_name in model_dict.keys():
+        model_file=model_dict[model_name]
+        substrates = get_substrates(model_file, exchanges)
+        all_substrates.extend(substrates)
+    all_substrates = list(set(all_substrates))
+    conditions = {substrate:initial_value for substrate in all_substrates}
+    biomasses = {model:biomass for model in model_dict.keys()}
+    conditions = conditions | biomasses
+    return conditions
+
+def initial_environment(volume=1, initial_counts=None, species_list=None):
+    """Construct initial shared environment store
+    Parameters:
+        volume : float, volume of the environment
+        initial_counts : dict, initial counts of each substrate and species biomass in the environment
+        species_list : list of strings, list of dfba species names)
+    Returns:
+        initial shared environment store spec
+    """
+    if initial_counts is None:
+        if species_list is None:
+            raise ValueError("Error: Please provide initial_counts or species_list")
+        initial_counts = {
+            "glucose": 80,
+            "acetate": 0,
+        }
+        for species in species_list:
+            initial_counts[species] = 0.5
+
+    initial_concentration = {key:(count/volume) for key, count in initial_counts.items()}
+
+    return {
+        "volume": volume,
+        "counts": initial_counts,
+        "concentrations": initial_concentration
+    }
+
+#environmental process/step related functions
+def environment_spec():
+    """Construct spec dictionary for UpdateEnvironment step"""
+    return {
+        "_type": "process",
+        "address": "local:UpdateEnvironment",
+        "config": {},
+        "inputs": {
+            "species_updates": ["dFBA Results"],
+            "shared_environment": ["shared environment"]
+        },
+        "outputs": {
+            "shared_environment": ["shared environment"],
+        }
+    }
+
+def get_chemo_spec(config=None):
+    """Constructs a configuration dictionary for the Chemostat process.
+    Parameters:
+        config: dict, Chemostat configuration dictionary
+    Returns:
+        dict, spec for Chemostat process
+    """
+    if config is None:
+        raise ValueError("Error: Please provide config")
+    return {
+        "_type": "process",
+        "address": "local:Chemostat",
+        "config": config,
+        "inputs": {
+            "shared_environment": ["shared environment"],
+            "global_time": ["global_time"],
+        },
+        "outputs": {
+            "shared_environment": ["shared environment"],
+        },
+    }
+
+def get_wave_spec(config=None):
+    """Constructs a configuration dictionary for the WaveFunction process.
+    Parameters:
+        config: dict, WaveFunction configuration dictionary
+    Returns
+        dict, spec for WaveFunction process
+    """
+    if config is None:
+        raise ValueError("Error: Please provide config")
+    return {
+        "_type": "process",
+        "address": "local:WaveFunction",
+        "config": config,
+        "inputs": {
+            "shared_environment": ["shared environment"],
+            "global_time": ["global_time"],
+        },
+        "outputs": {
+            "shared_environment": ["shared environment"],
+        },
+    }
+
+def get_injector_spec(config=None):
+    """Constructs a configuration dictionary for the Injector process.
+    Parameters:
+        config: dict, Injector configuration dictionary
+    Returns:
+        dict, spec for Injector process
+    """
+    if config is None:
+        raise ValueError("Error: Please provide config")
+    return {
+        "_type": "process",
+        "address": "local:Injector",
+        "config": config,
+        "inputs": {
+            "shared_environment": ["shared environment"],
+            "global_time": ["global_time"],
+        },
+        "outputs": {
+            "shared_environment": ["shared environment"],
+        },
+    }
+
+def run_single_dfba_spec(model_file="textbook"):
+    model = model_from_file(model_file)
+    exchanges = get_exchanges(model_file=model_file, medium_type='exchange')
+    substrates = get_substrates(model_file=model_file, exchanges=exchanges)
+    reaction_map = get_reaction_map(model_file=model_file, exchanges=exchanges)
+    kinetics = get_kinetics(model_file=model_file, exchanges=exchanges)
+    bounds=None
+    biomass_identifier = get_objective_reaction(model_file=model_file)
+    config = dfba_config(
+        model_file=model_file,
+        name='E.coli Core',
+        kinetics=kinetics,
+        reaction_map=reaction_map,
+        biomass_identifier=biomass_identifier,
+        bounds=bounds,
+    )
+    spec = get_single_dfba_spec(
+        model_file=model_file,
+        name='E.coli Core',
+        config=config,
+        interval=1.0
+    )
+
+    pprint.pprint(spec)
+    print("")
+    print(f"Exchanges: {exchanges}")
+    print(f"Substrates: {substrates}")
+    print(f"Reaction Map: {reaction_map}")
+    print(f"Kinetics: {kinetics}")
+    print(f"Biomass Identifier: {biomass_identifier}")
+    print(f"Bounds: {bounds}")
+
+def run_initial_counts(model_file="textbook"):
+    exchanges = get_exchanges(model_file=model_file, medium_type='exchange')
+    initial_counts = get_initial_counts(
+        model_dict={'E.coli Core': 'textbook'},
+        biomass=0.1,
+        initial_value=20,
+        exchanges=exchanges
+    )
+
+    pprint.pprint(initial_counts)
+
+def run_cdfba_spec():
+    model_dict = {
+        'E.coli' : 'iAF1260',
+        'S. flexneri' : 'iSFxv_1172'
+    }
+
+    pprint.pprint(make_cdfba_composite(
+        model_dict=model_dict,
+        medium_type='exchange',
+        exchanges=None,
+        volume=1,
+        interval=1.0
+        )
+    )
+
+if __name__ == '__main__':
+    # run_single_dfba_spec(model_file="textbook")
+    # run_initial_counts(model_file="textbook")
+    run_cdfba_spec()

cdfba-0.0.1/cdFBA.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.2
+Name: cdFBA
+Version: 0.0.1
+Home-page: https://github.com/vivarium-collective/cdFBA
+Author: Tasnif Rahman
+Author-email: trahman@uchc.edu
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: vivarium-interface
+Requires-Dist: cobra
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# cdFBA
+Community Dynamic Flux Balance Analysis using process-bigraph. 
+
+
+#### This project is a work in progress

cdfba-0.0.1/cdFBA.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+cdFBA/__init__.py
+cdFBA/utils.py
+cdFBA.egg-info/PKG-INFO
+cdFBA.egg-info/SOURCES.txt
+cdFBA.egg-info/dependency_links.txt
+cdFBA.egg-info/requires.txt
+cdFBA.egg-info/top_level.txt
+cdFBA/processes/__init__.py
+cdFBA/processes/dfba.py

cdfba-0.0.1/cdFBA.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cdfba-0.0.1/cdFBA.egg-info/requires.txt

@@ -0,0 +1,3 @@
+vivarium-interface
+cobra
+matplotlib

cdfba-0.0.1/cdFBA.egg-info/top_level.txt

@@ -0,0 +1 @@
+cdFBA

cdfba-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cdfba-0.0.1/setup.py

@@ -0,0 +1,53 @@
+import re
+from setuptools import setup, find_packages
+
+
+VERSION = '0.0.1'
+
+
+with open("README.md", "r") as readme:
+    description = readme.read()
+    # Patch the relative links to absolute URLs that will work on PyPI.
+    description2 = re.sub(
+        r']\(([\w/.-]+\.png)\)',
+        r'](https://github.com/vivarium-collective/cdFBA/raw/main/\1)',
+        description)
+    long_description = re.sub(
+        r']\(([\w/.-]+)\)',
+        r'](https://github.com/vivarium-collective/cdFBA/blob/main/\1)',
+        description2)
+
+setup(
+    name="cdFBA",
+    version=VERSION,
+    author="Tasnif Rahman",
+    author_email="trahman@uchc.edu",
+    description="",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    license="MIT",
+    license_files=["LICENSE"],
+    url="https://github.com/vivarium-collective/cdFBA",
+    # packages=find_packages(),
+    packages=[
+        'cdFBA',
+        'cdFBA.processes',
+    ],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+    python_requires=">=3.9",
+    install_requires=[
+        "vivarium-interface",
+        "cobra",
+        "matplotlib"
+    ]
+)