mobspy.modules package — MobsPy 2.2 documentation

# mobspy.modules package

## Submodules

## mobspy.modules.class_of_meta_specie_named_any module

The class_of_meta_specie_named_any.py model is responsible for defining the Context_specie_named_any class.

class mobspy.modules.class_of_meta_specie_named_any.Context_specie_named_any(name)

  Bases: `Species`

  Class which inherits from Species. It only has one object, Any, which is defined at the end of this script. It is used to simplify the syntax of reactions and count setting inside the body of a “with Any.example_characteristic1 :” statement. Is is compatible with event_condition and event_time methods of the Simulation class. It can be nested and used several time in the same with statement.

  context_finish_for_meta_specie_named_any()

    This removes the context which is ending from _list_of_nested_any_contexts and updates the current Any context. Then, it updates the Any context in all meta-species.

  context_initiator_for_meta_specie_named_any()

    This adds the current context in _list_of_nested_any_contexts and then updates the Any context in all meta-species.

## mobspy.modules.event_functions module

mobspy.modules.event_functions.format_event_dictionary_for_sbml(species_for_sbml, event_list, characteristics_to_object, volume, dimension, meta_species_to_simulate, parameter_exist, parameters_in_events)

  Creates events_for_sbml dictionary for sbml file construction on the sbml_simulator/SBMLWriter.py

  Parameters:

    - species_for_sbml – (dict) {‘species_string’: count, ….}

    - event_list – [{‘species’:’meta_species_object’, ‘characteristics’:[‘list of characteristics’], ‘quantity’: number or pint object}

    - characteristics_to_object – {‘characteristic’:’meta_species_object’, …..}

    - volume – Simulation volume for unit conversion

    - dimension – Dimension of the system 2D, 3D, 4D, e

  Returns:

    event dictionary for the sbml file construction

  Return type:

    events = {‘e’: { ‘trigger’: ‘true’, ‘delay’: ‘10’, ‘assignments’: [(‘M’,’1’),]}}

## mobspy.modules.function_rate_code module

mobspy.modules.process_result_data.py

Handles rate_assignment to the reactions:

  The passing of arguments to be executed by the user supplied rate function The construction of mass action kinetics Handles the different types of rates supplied by the user

mobspy.modules.function_rate_code.basic_kinetics_string(reactants, reaction_rate, type_of_model, is_count=False)

  This constructs the bases for mass-action kinetics. Both for stochastic and deterministic depending on the type of model

  Params reactants:

    (list of str) list of reactants in MobsPy str format

  Params reaction_rate:

    (float) reaction constant

  Params type_of_model:

    (str) stochastic or deterministic - rate expressions are different depending on each case

  Returns:

    kinetics_string (str) mass action kinetics expression for the reaction

mobspy.modules.function_rate_code.deterministic_string(reactant_name, number)

  This function returns the deterministic string expression for mass action kinetics For instance the reaction 2A -> 3A would imply A*A It only does so for one reactant, so it must be called for all reactants in the reaction

  Params reactant_name:

    (str) species string involved in the reaction

  Params number:

    (int) stoichiometry (number of times it appears)

  Returns:

    to_return_string (str) the mass action kinetics string expression for only that species

mobspy.modules.function_rate_code.extract_reaction_rate(combination_of_reactant_species, reactant_string_list, reaction_rate_function, type_of_model, dimension, function_rate_arguments, parameter_exist, parameters_in_reaction, skip_check)

  This function is responsible for returning the reaction rate string for the model construction. To do this it does a different action depending on the type of the reaction_rate_function (we consider constants as functions) It passes the rate as a string expression in MobsPy standard units

  Parameters:

    - function_rate_arguments – list of strings of the function rate argument ex:[‘r1’, ‘r2’, ….]

    - combination_of_reactant_species – (list of Species) Meta-species currently being used in this reaction

    - reactant_string_list – (list of strings) list of species strings in order they apear in the reaction

    - reaction_rate_function – (float, callable, Quantity) rate stored in the reaction object

    - dimension – (int) system dimension (for the rate conversion)

  Returns:

    reaction_rate_string (str) the reaction kinetics as a string for SBML

mobspy.modules.function_rate_code.prepare_arguments_for_callable(combination_of_reactant_species, reactant_string_list, rate_function_arguments, dimension)

  This function prepares the requested arguments to the rate function for a given reaction by creating objects of the Specific_Species_Operator class

  Params combination_of_reactant_species:

    meta-species involved in the reaction

  Params reactant_string_list:

    species strings involved in the reaction

  Params rate_function_arguments:

    arguments received by the rate function

mobspy.modules.function_rate_code.search_for_parameters_in_str(reaction_rate_string, parameters_exist, parameters_in_reaction)

mobspy.modules.function_rate_code.stochastic_string(reactant_name, number)

  This function returns the stochastic string expression for mass action kinetics For instance the reaction 2A -> 3A would imply A*(A-1)/2 It only does so for one reactant, so it must be called for all reactants in the reaction

  Params reactant_name:

    (str) species string involved in the reaction

  Params number:

    (int) stoichiometry (number of times it appears)

  Returns:

    to_return_string (str) the mass action kinetics string expression for only that species

## mobspy.modules.logic_operator_objects module

class mobspy.modules.logic_operator_objects.MetaSpeciesLogicResolver(operation, simulation_context=None)

  Bases: `object`

  This object stores the logical and comparison operations that become the event triggers for conditions or the conditional duration for simulations

  Parameters:

    operation – (list) the logical operation that will be transformed in a string for copasi. Format ex

  [{object: …, characteristics:…}, ‘<=’, 10] :param simulation_context: (Simulation) simulation under context

  add_double_symbol(symbol, number)
  classmethod find_all_species_strings(species, characteristics, species_for_sbml)
  generate_string(characteristics_to_object, to_sort=False)

class mobspy.modules.logic_operator_objects.ReactingSpeciesComparator

  Bases: `SpeciesComparator`

  This class implements the comparisons necessary for events and conditional durations for Reacting Species ex (A.a1 > 5)

  Parameters:

    _simulation_context – (Simulation) current simulation under context

  add_operation_and_number(symbol, number)

    Adds the symbol and number to create a MetaSpeciesLogicResolver object

    Parameters:

      - symbol – Comparative symbols ‘<=’, ‘<’, ‘>=’, or ‘>’

      - number – (int) if compared to a value, (Species or ReactingSpecies) if compared to the objects

    Returns:

      MetaSpeciesLogicResolver object containing the comparison

  check_context()

    Checks if a reacting species is under context and add it to the attribute self._simulation_context

class mobspy.modules.logic_operator_objects.SpeciesComparator

  Bases: `object`

  This class implements the comparisons necessary for events and conditional durations for Species ex (A > 5)

  Parameters:

    _simulation_context – (Simulation) current simulation under context

  add_operation_and_number(symbol, number)

    Creates a MetaSpeciesLogicResolver from the comparison of a meta-species with a value or another meta-species

    Parameters:

      - symbol – Comparison symbol ‘>=’, ‘<=’, ‘>’ or ‘<’

      - number – (int) if compared to a value, (Species or ReactingSpecies) if compared to the objects

  classmethod check_parenthesis(code_line, line_number, pos, symbol, number_of_comp)

    > This function compiles part of a logic expression for meta-species. It checks to see if an operator ‘<’ or ‘>’ is properly written inside parenthesis. It only applies if more than one operator is present in the code line

    Parameters:

      - code_line – (str) line of code to be compiled

      - line_number – (str) number of the code line currently being compiled

      - pos – (int) position of the ‘>’ or ‘<’ operator

      - symbol – ‘(’ or ‘)’, indicates in which direction the string analysis should proceded

      - number_of_comp – for distinction the default case where only one operator is present

    Raises:

      simlog.error – if the code line is not properly written isolating the clauses with parenthesis

    Returns:

      (bool) false if the line compiles, raises a error if it does not

  classmethod compile_code_line()

    Compiles the code line executing a logical operation

    Raises:

      simlog.error – if the code line is not properly written isolating the clauses with parenthesis

  classmethod logical_add_reacting_species(react_spe)

    Adds a reacting species object to an event trigger operation by summing over all the indicated characteristics. It also accepts sums of species multiplied by integers

    Parameters:

      react_spe – (ReactingSpecies) ReactingSpecies object

  classmethod logical_add_species(species)

    Adds a species object to an event trigger operation

    Parameters:

      species – (Species) species object

  reformat_number_and_species(number)

    Discovers if the number is a Species, ReactingSpecies or integer and prepares the output accordingly

    Parameters:

      number – (int) if compared to a value, (Species or ReactingSpecies) if compared to the objects

## mobspy.modules.meta_class module

The meta_class.py model is responsible for defining the meta-species, meta-reactions and other “meta-classes” It is also responsible for compiling the models into data structures that will be converted into an SBML file later Bear in mind that they are not actually Python meta-classes. The first design utilized this feature but know there are just regular classes

mobspy.modules.meta_class.BaseSpecies(number_or_names=None)

  Function that returns a number of base species according to the number_of_properties BaseSpecies are just Species with no inheritance attached to it

  Parameters:

    number_or_names – (int) number of base species wanted or (list) list of names of wanted Species

  Returns:

    Species objects according to the number of species requested

class mobspy.modules.meta_class.Compiler

  Bases: `object`

  The compiler is responsible for constructing the model from the meta-species and meta-reactions given and checking if it is a valid MobsPy model

  classmethod add_phantom_reactions(reactions_for_sbml, species_to_add_phantom_reaction)

    This method is here because basico cannot compile species that have been assigned to events but are not present in reactions. Interestingly enough this error does not happen in python 3.10. However, to be compatible with earlier versions we add an extremely slow phantom reaction for each one of those species with a coefficient of 1e-100. The idea is that the reaction is so slow that it should not make any sizable difference in any model. It adds them directly to the reactions for sbml dictionary

    Parameters:

      - reactions_for_sbml – reactions dictionary in python sbml format

      - species_to_add_phantom_reaction – species that will be assigned a phantom reaction

  classmethod add_to_parameters_to_sbml(parameters_used, parameters_for_sbml, parameters_to_add)
  classmethod compile(meta_species_to_simulate, reactions_set, species_counts, orthogonal_vector_structure, volume=1, type_of_model='deterministic', verbose=True, event_dictionary=None, continuous_sim=False, ending_condition=None, skip_expression_check=False)

    Here we construct the species for Copasi using their objects

    It handles the construction of species_for_sbml, reactions_for_sbml, parameters_for_sbml, mappings_for_sbml, model_str which will be used to write the sbml_string for basiCO It also performs checks to see if the model is valid

    Parameters:

      - meta_species_to_simulate – (List_Species or Species) Species to generate the model

      - reactions_set – (set) Set of meta-reactions collected when the simulation objected was constructed

      - species_counts – (dict) All counts assigned to species in the model before the simulation object was constructed

      - orthogonal_vector_structure – (dict) ref_characteristics_to_objects in other modules. Dictionary

    with the characteristics as keys and the objects as values. Characteritics pointing to their coordinate in the vector space :param volume: (int, flot) Simulation volume :param type_of_model: (str) deterministic or stochastic :param verbose: (bool) print or not the model results by generating a model_str meta-reaction ( or Default we have the round-robin) and how MobsPy will handle meta-species in the products that are not referenced in the reactants - see order_operators.py :param event_dictionary: (dict) dictionary with all the events to be added to the model :param continuous_sim: (bool) simulation with conditional duration or not :param ending_condition: (MetaSpeciesLogicResolver) trigger for the ending contion

    Returns:

      species_for_sbml (dict) = dictionary where the species strings (in MobsPy format) are the keys and

    the values are their counts inside the model. reactions_for_sbml (dict) = Reaction in dictionary format with keys ‘re’, ‘pr’ and ‘rate’. Values are strings parameters_for_sbml (dict) = value with parameter name and tuple with quantity and unit. For standard models it only holds the volume mappings_for_sbml (dict) = Dictionary that maps a meta-species to the set of species strings that belong to it. model_str (str) = str of the variables defined above in a user-readable format. events_for_sbml (dict) = dictionary containing the event trigger and count assignments. assigned_species (list) = list of meta-species which had counts assigned to them during this model execution (used when composing simulations)

  entity_counter = 3
  last_rate = None
  classmethod override_get_item(object_to_return, item)

    Due to priority in Python the item is stored before the reaction So it is stored in the Compiler level and passed to the reaction object in the end Important: the rate is used before the compilation level, it’s used when the reaction has been completely defined

    Parameters:

      - object_to_return – (Species or Reacting) returns the object that the __getitem__ was performed on

      - item – (int, float, callable, Quantity) stored reaction rate

  ref_characteristics_to_object = {}

mobspy.modules.meta_class.ListSpecies(number_of_elements, inherits_from=None)

class mobspy.modules.meta_class.List_Species(iterable)

  Bases: `object`

  This class just stores species after the | operation. It creates a list of species than can be loop through or given to the simulator

  Parameters:

    list_of_species – (Species) Meta-species list to store the meta-species

  append(species)

    Add species to the list_of_species

    Parameters:

      species – (Species) meta-species to be added to the List_Species

  extend(other)
  insert(index, item)
  is_in(item)
  remove(value)

    Removes all instances of the meta-species in the object

    Returns:

      The number of instances removed

  remove_repeated_elements()

    This function creates a List_Species with no repetitions. The order of elements is lost

    Returns:

      List_Species with no repeated elements

mobspy.modules.meta_class.New(species, number_or_names=None)

  Function that returns a number of meta-species that inherit from the species supplied

  Parameters:

    number_or_names – (int) number of meta-species wanted, (list) list of names wanted

  Returns:

    Species objects according to the number of species requested

class mobspy.modules.meta_class.Reacting_Species(object_reference, characteristics, stoichiometry=1, label=None)

  Bases: `ReactingSpeciesComparator`

  This is a intermediary object created when a species is used in a reaction. It is created when a species is part of a reaction, so it’s constructor is called by the Species class in several of it’s methods. It transforms a Species object into a list packable object to pass to create the reaction object. This list format allows for easy concatenation of reactants by summing

  The >> operator calls the Reaction constructor to finally define a reaction object

  Parameters:

    list_of_reactants – (list of dict) used interchangeably for products and reactants.

  A list of dictionaries containing the following {‘object’: meta-species object reference, ‘characteristics’: the characteristics queried, ‘stoichiometry’: stoichiometry value, ‘label’: label if used (None)}

  c(item)

    c query implementation, queries by the value inside a variable instead of the name it just calls __getattr__ with the value inside the variable

    Parameters:

      item – value to query over

  context_finish_for_reacting_specie()

    This removes the context which is ending from _list_of_nested_any_contexts and updates the current Cts context. Then, it updates the Cts context in all meta-species.

  context_initiator_for_reacting_specie()

    This adds the current context in _list_of_nested_any_contexts and then updates the Cts context in all meta-species.

  classmethod is_spe_or_reac()
  classmethod is_species()
  label(label)

    Label function implementation. This function assigns labels to meta-species to be matched by the compiler later

    Parameters:

      label – (int, float, str) value for the label for matching

  old_context = {}

class mobspy.modules.meta_class.Reactions(reactants, products)

  Bases: `object`

  This is the Reaction class. It contains the reactants, products, rate and order Reactions are created with the >> operator. In each reaction is stored in all involved objects

  Parameters:

    - reactants – (list of Species) list of meta-species used as reactants in the meta-reaction

    - products – (list of Species) list of meta-species used as products in the meta-reaction

    - order – (Order Operator) reaction order operator - default in a Round-Robin base

    - rate – (int, float, callable, Quantity) reaction rate

  set_rate(rate)

    Sets the stored reaction rate. See Compiler.override_get_item(self, item)

    Parameters:

      rate – (int, float, callable, Quantity) = reaction rate

class mobspy.modules.meta_class.Species(name)

  Bases: `SpeciesComparator`

  Fundamental class - The meta-species object Contains the characteristics, the species name, the reactions it is involved in and finally the other species it references Objects store all the basic information necessary to create an SBML file and construct a model So we construct the species through reactions and __getattr__ to form a model

  Parameters:

    _name – (str) name of the species - named firstly as N$Counter as a placeholder. During compilation it is

  named by MobsPy to be equal to the variable name. It can also be named by the user using one the methods :param _characteristics: (str) set of characteristics DIRECTLY added to a species, does not contain inherited characteristics :param _references: (set) set of meta-species a meta-species has inherited from (used in it’s construction). Every species contains itself in this set :param first_characteristic: (str) first characteristic added to the species :param _reactions: (set) Every species stores all reactions is involved in. The compiler performs the union of the set with all species and species in the _references set to get the reactions back :param _species_counts: (list) counts listed for the species. Stores dictionaries with the characteristics as keys and the counts of values

  add_characteristic(characteristic)
  add_quantities(characteristics, quantity)

    This function was implemented because Python can’t accept sets as dictionary keys Set the quantity of an specific string of species

    Parameters:

      - characteristics – (str) characteristics of the species to be set

      - quantity – (int, float, Quantity) counts of that specific species

  add_reaction(reaction)
  add_reference(reference)
  c(item)

    c query implementation, queries by the value inside a variable instead of the name it just calls __getattr__ with the value inside the variable

    Parameters:

      item – value to query over

  classmethod check_if_valid_characteristic(char)

    Checks if the characteristics is valid. If there is any conflict between the methods of the class or attributes of the class the user will be asked to rename the characteristic

    Param:

      char - name of the characteristic to be added:

    Raises:

      simlog.error if the characteristic name is not allowed

    Returns:

      True if characteristic is allowed false if not

  get_all_characteristics()

    Different that get_characteristics. This function the characteristics directly added to it and the characteristics of the references. While get_characteristics only returns the characteristics directly added to that meta-species.

  get_characteristics()
  get_index_from_reference_dict(reference)
  get_name()
  get_ordered_references()
  get_quantities()
    Returns:

      The list of species_counts

  get_reactions()
  get_references()
  classmethod get_simulation_context()
  classmethod is_spe_or_reac()
  classmethod is_species()
  label(label)

    Label function implementation. This function matches equal meta-species if they have equal labels Here it returns a Reacting_Species as labels need to be used in reactions

    Parameters:

      label – (int, float, str) value for the label for matching

    Returns:

      Reacting_Species object created with the label in the constructor

  meta_specie_named_any_context = {}
  name(name)

    Function to name a species. Allows the user to use a name different from the variable’s name

    Parameters:

      name – (str) name of the species

  order_references()
  print_characteristics()
  remove_characteristic(characteristic)
  remove_repeated_elements()

    Defined to be consistent with the model behavior from List_Species :return: Itself

  reset_counts()
  reset_quantities()

    Just reset the counts inside a species - potentially useful in jupyter environment

  reset_reactions()
  reset_references()
  classmethod reset_simulation_context()
  set_reactions(reactions)
  set_references(reference_set)
  classmethod set_simulation_context(sim)
  show_characteristics()

    Prints the directly characteristics inside the object

  show_quantities()

    Shows the species counts stored in this object

  show_reactions()

    Prints the reactions inside the object

  show_references()

    Prints the objects this object has inherited from (including self)

  classmethod str_under_context(species_object, characteristics)

    Returns the str representation of a species under context or not

    Parameters:

      - species_object – Meta-species object to construct the string

      - characteristics – Characteristics to filter the strings

    Returns:

      String in format (A_dot_a1 + A_dot_a2 + ….) with the parenthesis

  unit(unit)
  classmethod update_meta_specie_named_any_context(meta_specie_named_any_characteristics)

    This updates the class variable meta_specie_named_any_context with the characteristics of the current any context.

    Parameters:

      meta_specie_named_any_characteristics – (set) set of characteristics of the currently active any context.

mobspy.modules.meta_class.compile_species_number_line(code_line)

  Compiles code line for BaseSpecies and New

  Parameters:

    code_line –

    - Line of code where BaseSpecies or New has been called

  Returns:

    n (int) = number of variables after a coma, names (list) = list of strings with the names of the

  variables

## mobspy.modules.meta_class_utils module

This model stores function used by the meta_class.py module

mobspy.modules.meta_class_utils.check_orthogonality_between_references(references)

  Check if meta-species objects inside a reference do not have characteristics in common The sets of characteristics directly added to species must be independent

  Parameters:

    references – (set) set of meta-species objects to check for independence

  Raises:

    simlog.error – raises error if there are repeated characteristics in different meta-species

mobspy.modules.meta_class_utils.combine_references(species1, species2)

  Combine the sets of references of two species

  Parameters:

    - species1 – (Meta-species object)

    - species2 – (Meta-species object)

mobspy.modules.meta_class_utils.complete_characteristics_with_first_values(spe_object, characteristics, characteristics_to_object)

  This creates a string with the species object name and the set of all first characteristics added to it’s base species used to construct it It allows us to search for the proper string in the model using the result of this function It’s used to set the quantities using the call method in Species and Reacting_Species

  Parameters:

    - spe_object – (meta-species object) meta-species to generate the species states with the first values

    - characteristics – (str) if there are characteristics to use instead of the default

    - characteristics_to_object – (dict) dictionary with characteristics as keys and the meta-species which

  they have been added to directly as value (no inheritance or New)

  Returns:

    Set with the species name and characteristics

mobspy.modules.meta_class_utils.create_orthogonal_vector_structure(species)

  This creates the independent state-structure for the model It is just a dictionary where the keys are characteristics and the values are meta-species objects that have been directly added to that object (no inheritance or New) It simplifies the code by allowing to easily keep track of the ‘axis’ of each characteristic. Allowing for easy transformation on the products and others

  Parameters:

    species – (meta-species objects) - meta-species objects used in a model

  Return ref_characteristics_to_object:

    (dict) a dictionary where the keys are characteristics and the

  values are meta-species objects that have been directly added to that object

mobspy.modules.meta_class_utils.unite_characteristics(species)

  This function unites the characteristics of all the given species

  Parameters:

    species – (list of species or List_Species object)

## mobspy.modules.mobspy_expressions module

class mobspy.modules.mobspy_expressions.Bool_Override

  Bases: `object`

  Just a base class for implementing the . operation in the rate function arguments through boolean overriding. It is responsible for returning true when the reactant has the specified characteristic when using the dot notation

  Parameters:

    - _stocked_characteristics – (str) stocks the characteristics of the queries performed by the user

    - species_string – (str) string value from an individual species in MobsPY format

class mobspy.modules.mobspy_expressions.ExpressionDefiner

  Bases: `object`

  combine_binary_attributes(other, attribute)
  create_from_new_operation(other, symbol, count_op, conc_op, direct_sense=True, operation=None)
  classmethod execute_op(first, second, operation)
  execute_quantity_op(other, operation)

class mobspy.modules.mobspy_expressions.MobsPyExpression(species_string, species_object, operation=None, unit_count_op=1, unit_conc_op=<Quantity(1, '1 / liter')>, dimension=None, expression_variables=None, parameter_set=None, count_in_model=True, concentration_in_model=False, count_in_expression=True, concentration_in_expression=False, has_units=False)

  Bases: `Specific_Species_Operator`, `ExpressionDefiner`

  generate_string_operation(skip_check=False, reaction_order=None)

class mobspy.modules.mobspy_expressions.OverrideQuantity(value: MagnitudeT, units: UnitLike | None = None)
class mobspy.modules.mobspy_expressions.OverrideQuantity(value: str, units: UnitLike | None = None)
class mobspy.modules.mobspy_expressions.OverrideQuantity(value: Sequence[ScalarT], units: UnitLike | None = None)
class mobspy.modules.mobspy_expressions.OverrideQuantity(value: PlainQuantity[Any], units: UnitLike | None = None)

  Bases: `ExpressionDefiner`, `Quantity`

  convert(unit)
  convert_into(unit)
  non_expression_add(other)
  non_expression_mul(other)
  non_expression_pow(other)
  non_expression_radd(other)
  non_expression_rmul(other)
  non_expression_rsub(other)
  non_expression_rtruediv(other)
  non_expression_sub(other)
  non_expression_truediv(other)
  set_ms_active(ms_active)

class mobspy.modules.mobspy_expressions.OverrideUnitRegistry

  Bases: `object`

class mobspy.modules.mobspy_expressions.QuantityConverter

  Bases: `object`

  classmethod convert_received_unit(quantity)

class mobspy.modules.mobspy_expressions.Specific_Species_Operator(species_string, species_object)

  Bases: `Bool_Override`

  This class creates objects from the species strings from the meta-species to pass them to the rate functions as arguments. It uses the Bool_Override class to return true or false to the .dot operation inside the rate functions

  Parameters:

    - _stocked_characteristics – (str) stocks the characteristics of the queries performed by the user

    - species_string – (str) string value from an individual species in MobsPY format

    - species_object – (Species) Meta-species object which originated the meta-species str

  add(characteristic)

    Adds characteristic to the set of characteristics when checking for all referred characteristics by the user

    Parameters:

      characteristic – (str) characteristic to add to the set

  get_characteristics()

    Returns: The characteristics of the species in this given state

  get_name()

    Returns: The name of the species the reactant is in string format

  is_a(reference)

    This function checks to see if the meta-species the species_string belong to has inherited from the parameter reference (reminder: every meta-species inherits from itself)

    Parameters:

      reference – (Species) Meta-species object

    Returns:

      (bool) True if the meta-species in Specific_Species_Operator has inherited from the reference

    False otherwise

## mobspy.modules.mobspy_parameters module

class mobspy.modules.mobspy_parameters.Mobspy_Parameter(name, value)

  Bases: `ExpressionDefiner`, `QuantityConverter`

  parameter_stack = {}
  rename(new_name)

mobspy.modules.mobspy_parameters.ModelParameters(*args)

## mobspy.modules.order_operators module

This module deals with order_operators Thus it deals with the Round-Robin order assignment and with species in the products that are not referenced in the reactants (Born Species) It has also the implementation of the Rev operator, since that is a also a reaction operator

## mobspy.modules.reaction_construction_nb module

This module is responsible for the construction of all individual reactions from a meta-reaction

mobspy.modules.reaction_construction_nb.check_for_invalid_reactions(reactions, ref_characteristics_to_object)

  If query references two independent characteristics from the in meta-species it would result in an empty set Like Ecoli.live.dead - (assuming live and dead belong to the same meta-species characteristics set) If that ever happens inside a meta-reaction we just pop an error

  Parameters:

    - reactions – (set of meta-reactions) set of meta-reactions inside the model

    - ref_characteristics_to_object – (dict) dictionary with the characteristics as keys and their respective

  object as values

mobspy.modules.reaction_construction_nb.construct_order_structure(species_order_list, current_species_string_list)

  Order structure for reaction order operations. Returns the cyclic_dictionary to be used by the order operator. The meta-species objects are the keys of this dictionary and a lists of species strings currently being used in the reaction are the values - Allowing the product to find it’s corresponding species-string in a future step

  Parameters:

    species_order_list – (list of meta-species objects) list of meta-species objects as they appear in the

  meta-reaction :param current_species_string_list: (list of strings) list of strings in MobsPy format of the species currently in this specific reaction

  Returns:

    cyclic_dict (dict) Dictionary where the keys are meta-species objects and the values are

  lists of species

mobspy.modules.reaction_construction_nb.construct_product_structure(reaction)

  This function unpacks the products in a meta-reaction

  Param:

    reaction meta-reaction currently being analysed

  Returns:

    product_list = A list of dictionaries for each product with the meta-species object, the label and the

  characteristics

mobspy.modules.reaction_construction_nb.construct_rate_function_arguments(rate_function, reaction)

mobspy.modules.reaction_construction_nb.construct_reactant_structures(reactant_species, ref_characteristics_to_object)

  This function finds the corresponding strings according to the reactant meta-species with or without a query pack then in a list and return

  Parameters:

    - reactant_species – (meta-species object) species objects of the involved species

    - ref_characteristics_to_object – (dict) dictionary with characteristics as keys and species objects as

  values

mobspy.modules.reaction_construction_nb.construct_single_reaction_for_sbml(reactant_species_string_list, product_species_string_list, reaction_rate)

  This function constructs the reactions for SBML for the conversion by the model builder script It follows the following structure ‘re’:[(‘stoichmetry’, reactantant_string) …. The reaction rate must be a string containing the reaction kinetics This returns a single reaction to be appended by the reactions_for_sbml dictionary

  Parameters:

    - reactant_species_string_list – (list of strings) list of reactants in MobsPy format

    - product_species_string_list – (list of strings) list of products in MobsPy format

    - reaction_rate – (str) reaction rate expression as a string

  Returns:

    to_return (dict) = dictionary that packs the reactants products and rate

mobspy.modules.reaction_construction_nb.copy_reaction(reaction)

  Just copies a meta-reaction Deepcopy is not working because it calls __getattr__ on the species with a private method

  Parameters:

    reaction (meta-reaction) –

mobspy.modules.reaction_construction_nb.count_string_dictionary(list_of_strings)

  Count the number of instances in a list and return them in a dictionary where the keys are the strings and the value the number of times it appeared in the list

mobspy.modules.reaction_construction_nb.create_all_reactions(reactions, meta_species_in_model, ref_characteristics_to_object, type_of_model, dimension, parameter_exist, parameters_in_reaction, skip_check)

  This function creates all reactions Returns the reactions_for_sbml and parameters_for_sbml dictionary Those will be used by another module to create the SBML file

  Parameters:

    - reactions – (meta-reaction objects) reactions objects constructed by the meta_class module

    - meta_species_in_model – (list) list of meta-species in model

    - ref_characteristics_to_object – (dict) Characteristics as keys objects as values

    - type_of_model – (str) stochastic or deterministic

    - dimension – (int) model dimension 1D, 2D, 3D, …..

  Returns:

    reactions_for_sbml (dict) = dictionary with all reactions that will be added to the sbml model file,

  parameters_for_sbml (dict) = parameters for the sbml model file

mobspy.modules.reaction_construction_nb.expression_compilation_finish(expressions)

  Sets _ms_active to false for all expressions found in the stack by expression_compilation_initiation()

mobspy.modules.reaction_construction_nb.expression_compilation_initiation()

  First find all ExpressionDefiner objects in the stack. Then, sets _ms_active to True to change the behavior of quantities and units in expressions

mobspy.modules.reaction_construction_nb.get_involved_species(reaction, meta_species_in_model)

  This extracts all the involved meta-species inside a reaction This function is responsible for implementing the inheritance mechanism, by finding within each meta-species references set, if they reference the meta-species in the reaction

  Parameters:

    - reaction – (meta-reaction object)

    - meta_species_in_model – (list) list of meta-species used in the model

  Returns:

    base_species_order (list of meta-species objects) = order that the meta-species appear in the

  meta-reaction, reactant_species_combination_list (list of lists of meta-species) = list of lists of all meta-species that have inherited from the meta-species in the meta-reaction

mobspy.modules.reaction_construction_nb.iterator_for_combinations(list_of_lists)

  Iterate through all the combinations of a list of lists [[A,B,C], [D, F, E], [G]] means: ADG, AFG, AEG, BDG, BFG, BEG, CDG, CFG, CEG …..

  Parameter:

    list_of_lists (list of lists) = list of all lists to iterate through all combinations

## mobspy.modules.reaction_construction_nb_parallel module

This module is responsible for the construction of all individual reactions from a meta-reaction

mobspy.modules.reaction_construction_nb_parallel.check_for_invalid_reactions(reactions, ref_characteristics_to_object)

  If query references two independent characteristics from the in meta-species it would result in an empty set Like Ecoli.live.dead - (assuming live and dead belong to the same meta-species characteristics set) If that ever happens inside a meta-reaction we just pop an error

  Parameters:

    - reactions – (set of meta-reactions) set of meta-reactions inside the model

    - ref_characteristics_to_object – (dict) dictionary with the characteristics as keys and their respective

  object as values

mobspy.modules.reaction_construction_nb_parallel.construct_order_structure(species_order_list, current_species_string_list)

  Order structure for reaction order operations. Returns the cyclic_dictionary to be used by the order operator. The meta-species objects are the keys of this dictionary and a lists of species strings currently being used in the reaction are the values - Allowing the product to find it’s corresponding species-string in a future step

  Parameters:

    species_order_list – (list of meta-species objects) list of meta-species objects as they appear in the

  meta-reaction :param current_species_string_list: (list of strings) list of strings in MobsPy format of the species currently in this specific reaction

  Returns:

    cyclic_dict (dict) Dictionary where the keys are meta-species objects and the values are

  lists of species

mobspy.modules.reaction_construction_nb_parallel.construct_product_structure(reaction)

  This function unpacks the products in a meta-reaction

  Param:

    reaction meta-reaction currently being analysed

  Returns:

    product_list = A list of dictionaries for each product with the meta-species object, the label and the

  characteristics

mobspy.modules.reaction_construction_nb_parallel.construct_rate_function_arguments(rate_function, reaction)

mobspy.modules.reaction_construction_nb_parallel.construct_reactant_structures(reactant_species, ref_characteristics_to_object)

  This function finds the corresponding strings according to the reactant meta-species with or without a query pack then in a list and return

  Parameters:

    - reactant_species – (meta-species object) species objects of the involved species

    - ref_characteristics_to_object – (dict) dictionary with characteristics as keys and species objects as

  values

mobspy.modules.reaction_construction_nb_parallel.construct_single_reaction_for_sbml(reactant_species_string_list, product_species_string_list, reaction_rate)

  This function constructs the reactions for SBML for the conversion by the model builder script It follows the following structure ‘re’:[(‘stoichmetry’, reactantant_string) …. The reaction rate must be a string containing the reaction kinetics This returns a single reaction to be appended by the reactions_for_sbml dictionary

  Parameters:

    - reactant_species_string_list – (list of strings) list of reactants in MobsPy format

    - product_species_string_list – (list of strings) list of products in MobsPy format

    - reaction_rate – (str) reaction rate expression as a string

  Returns:

    to_return (dict) = dictionary that packs the reactants products and rate

mobspy.modules.reaction_construction_nb_parallel.copy_reaction(reaction)

  Just copies a meta-reaction Deepcopy is not working because it calls __getattr__ on the species with a private method

  Parameters:

    reaction (meta-reaction) –

mobspy.modules.reaction_construction_nb_parallel.count_string_dictionary(list_of_strings)

  Count the number of instances in a list and return them in a dictionary where the keys are the strings and the value the number of times it appeared in the list

mobspy.modules.reaction_construction_nb_parallel.create_all_reactions(reactions, meta_species_in_model, ref_characteristics_to_object, type_of_model, dimension, parameter_exist, parameters_in_reaction)

  This function creates all reactions Returns the reactions_for_sbml and parameters_for_sbml dictionary Those will be used by another module to create the SBML file

  Parameters:

    - reactions – (meta-reaction objects) reactions objects constructed by the meta_class module

    - meta_species_in_model – (list) list of meta-species in model

    - ref_characteristics_to_object – (dict) Characteristics as keys objects as values

    - type_of_model – (str) stochastic or deterministic

    - dimension – (int) model dimension 1D, 2D, 3D, …..

  Returns:

    reactions_for_sbml (dict) = dictionary with all reactions that will be added to the sbml model file,

  parameters_for_sbml (dict) = parameters for the sbml model file

mobspy.modules.reaction_construction_nb_parallel.get_involved_species(reaction, meta_species_in_model)

  This extracts all the involved meta-species inside a reaction This function is responsible for implementing the inheritance mechanism, by finding within each meta-species references set, if they reference the meta-species in the reaction

  Parameters:

    - reaction – (meta-reaction object)

    - meta_species_in_model – (list) list of meta-species used in the model

  Returns:

    base_species_order (list of meta-species objects) = order that the meta-species appear in the

  meta-reaction, reactant_species_combination_list (list of lists of meta-species) = list of lists of all meta-species that have inherited from the meta-species in the meta-reaction

mobspy.modules.reaction_construction_nb_parallel.iterator_for_combinations(list_of_lists)

  Iterate through all the combinations of a list of lists [[A,B,C], [D, F, E], [G]] means: ADG, AFG, AEG, BDG, BFG, BEG, CDG, CFG, CEG …..

  Parameter:

    list_of_lists (list of lists) = list of all lists to iterate through all combinations

## mobspy.modules.set_counts_module module

mobspy.modules.set_counts_module.set_counts(count_dic)

  Adds counts to meta-species using a given dictionary. Keys from this dictionary can be either meta-species objects or strings. Items must be the assign counts to species

  Parameters:

    count_dic – Dictionary where keys can be either meta-species or strings

  Raises:

    simlog.error –

    - If a count is assigned to a Reacting_Species with more than one meta-species.

  If there are two species with the same name and a string assignment is performed. If the keys are not strings or meta-species. If the counts are not Quantities, Floats or Ints. If the species was not found in the stack. :return: List_Species object. All meta-species that had a count assigned in this dictionary will be returned as a List_Species which can be passed as a model to the simulation object

## mobspy.modules.species_string_generator module

mobspy.modules.species_string_generator.characteristics_dictionary(characteristics, characteristics_to_object)

  This function constructs a dictionary that leads from the species string characteristics to their respective object. This structure allows to easily find where the characteristics in a species string are locates

  Parameters:

    - characteristics – (set) of characteristics

    - characteristics_to_object – (dict) with characteristics as keys and their respective base meta-species

  object as value

mobspy.modules.species_string_generator.construct_all_combinations(spe_object, characteristics, characteristics_to_object, symbol=None)

  This function constructs all possible list in the format [‘species_name’, ‘char1’, ‘char2’, …] using all combinations of characteristics from the vector coordinates not used in the characteristics specified in the function argument. If a symbol is given it generates a string from the list using the symbol to join it.

  Parameters:

    - spe_object – meta-species object to be used

    - characteristics – (set) of characteristics given

    - characteristics_to_object – (dict) with characteristics as keys and their respective base meta-species

  object as value :param symbol: (str) usually . or _dot_, connects the elements from the list using the specified symbol

mobspy.modules.species_string_generator.construct_species_char_list(spe_object, characteristics, characteristics_to_object, symbol=None)

  This function constructs a list in the format [‘species_name’, ‘char1’, ‘char2’, …]. It generetes this list for a given meta-species and the specified characteristics. Values of characteristics not specified in a particular position are replaced by their default value. If a symbol is given it generates a string from the list using the symbol to join it.

  Parameters:

    - spe_object – meta-species object to be used

    - characteristics – (set) of characteristics given

    - characteristics_to_object – (dict) with characteristics as keys and their respective base meta-species

  object as value :param symbol: (str) usually . or _dot_, connects the elements from the list using the specified symbol

## mobspy.modules.unit_handler module

This module is responsible for dealing with units in the modules directory level MobsPy standard units are Decimeter (Liter) - Second - Count

mobspy.modules.unit_handler.check_dimension(dimension, value)

  Checks for dimension consistency. It “stores” the first dimension it was given by returning it

  Parameters:

    - dimension – (int) model’s dimension (1D, 2D, 3D …)

    - value – (int) dimension value being analysed

  Raises:

    simlog.error – If dimensions are not consistent through the given units (units in 1D with 2D mixed)

  Returns:

    dimension (int) = model’s dimension (1D, 2D, 3D …)

mobspy.modules.unit_handler.convert_counts(quantity, volume, dimension)

  This function converts the counts from the users given unit to MobsPy standard units. It also converts concentrations into counts

  Parameters:

    - quantity – (int, float, Quantity) If it is a quantity object convert, otherwise it remains the same

    - volume – (int, float) volume in liters (converted beforehand)

    - dimension – (int) model’s dimension (1D, 2D, 3D, … )

  Returns:

    converted_quantity (int, float) = converted unit into MobsPy standard units

mobspy.modules.unit_handler.convert_rate(quantity, reaction_order, dimension)

  This function converts the rate from the users given unit to MobsPy standard units

  Parameters:

    - quantity – (int, float, Quantity) If it is a quantity object convert, otherwise it remains the same

    - reaction_order – (int) number of reactants in the reaction, to check if the rate is in the correct unit

    - dimension – (int) model’s dimension (1D, 2D, 3D, … )

    - quantity – (int, float) converted unit into MobsPy standard units

mobspy.modules.unit_handler.convert_time(time)

  Converts time into seconds

  Parameters:

    time – (int, float, Quantity) any time used

mobspy.modules.unit_handler.convert_volume(volume, dimension)

  Converts volume to decimetre**dimension

  Parameters:

    volume – (int, float, Quantity) volume used in simulation

  Returns:

    the converted volume in MobsPy units

mobspy.modules.unit_handler.extract_length_dimension(unit_string, dimension, reaction_order=None)

  Extracts the volume dimension from a Quantity object from Pint

  Parameters:

    - unit_string – (str) unit in str format

    - dimension – (int) model’s dimension (1D, 2D, 3D …)

## mobspy.modules.user_functions module

mobspy.modules.user_functions.Apply(function, *args)

## Module contents