mcell/libmcell/generated/mcell.pyi

from typing import List, Dict, Callable, Any
from enum import Enum

INT32_MAX = 2147483647 # do not use this constant in your code

FLT_MAX = 3.40282346638528859812e+38 # do not use this constant in your code

# "forward" declarations to make the type hints valid
class BaseChkptMol():
    pass
class ChkptSurfMol():
    pass
class ChkptVolMol():
    pass
class Color():
    pass
class Complex():
    pass
class Component():
    pass
class ComponentType():
    pass
class Config():
    pass
class Count():
    pass
class CountTerm():
    pass
class ElementaryMolecule():
    pass
class ElementaryMoleculeType():
    pass
class GeometryObject():
    pass
class InitialSurfaceRelease():
    pass
class Instantiation():
    pass
class Introspection():
    pass
class Model():
    pass
class MolWallHitInfo():
    pass
class Molecule():
    pass
class MoleculeReleaseInfo():
    pass
class Notifications():
    pass
class Observables():
    pass
class ReactionInfo():
    pass
class ReactionRule():
    pass
class Region():
    pass
class ReleasePattern():
    pass
class ReleaseSite():
    pass
class RngState():
    pass
class Species():
    pass
class Subsystem():
    pass
class SurfaceClass():
    pass
class SurfaceProperty():
    pass
class SurfaceRegion():
    pass
class VizOutput():
    pass
class Wall():
    pass
class WallWallHitInfo():
    pass
class Warnings():
    pass
class bngl_utils():
    pass
class data_utils():
    pass
class geometry_utils():
    pass
class run_utils():
    pass

class Vec3():
    def __init__(self, x : float = 0, y : float = 0, z : float = 0):
        self.x = x
        self.y = y
        self.z = z

class Vec2():
    def __init__(self, u : float = 0, v : float = 0):
        self.u = u
        self.v = v

class Orientation(Enum):
    DOWN = -1
    NONE = 0
    UP = 1
    NOT_SET = 2
    ANY = 3
    DEFAULT = 4

class Notification(Enum):
    NONE = 0
    BRIEF = 1
    FULL = 2

class WarningLevel(Enum):
    IGNORE = 0
    WARNING = 1
    ERROR = 2

class VizMode(Enum):
    ASCII = 0
    CELLBLENDER_V1 = 1
    CELLBLENDER = 2

class Shape(Enum):
    UNSET = 0
    SPHERICAL = 1
    REGION_EXPR = 2
    LIST = 3
    COMPARTMENT = 4

class SurfacePropertyType(Enum):
    UNSET = 0
    REACTIVE = 1
    REFLECTIVE = 2
    TRANSPARENT = 3
    ABSORPTIVE = 4
    CONCENTRATION_CLAMP = 5
    FLUX_CLAMP = 6

class ExprNodeType(Enum):
    UNSET = 0
    LEAF = 1
    ADD = 2
    SUB = 3

class RegionNodeType(Enum):
    UNSET = 0
    LEAF_GEOMETRY_OBJECT = 1
    LEAF_SURFACE_REGION = 2
    UNION = 3
    DIFFERENCE = 4
    INTERSECT = 5

class ReactionType(Enum):
    UNSET = 0
    UNIMOL_VOLUME = 1
    UNIMOL_SURFACE = 2
    VOLUME_VOLUME = 3
    VOLUME_SURFACE = 4
    SURFACE_SURFACE = 5

class MoleculeType(Enum):
    UNSET = 0
    VOLUME = 1
    SURFACE = 2

class BNGSimulationMethod(Enum):
    NONE = 0
    ODE = 1
    SSA = 2
    PLA = 3
    NF = 4

class CountOutputFormat(Enum):
    UNSET = 0
    AUTOMATIC_FROM_EXTENSION = 1
    DAT = 2
    GDAT = 3



STATE_UNSET = 'STATE_UNSET'
STATE_UNSET_INT = -1
BOND_UNBOUND = -1
BOND_BOUND = -2
BOND_ANY = -3
PARTITION_EDGE_EXTRA_MARGIN_UM = 0.01
DEFAULT_COUNT_BUFFER_SIZE = 100
ALL_MOLECULES = 'ALL_MOLECULES'
ALL_VOLUME_MOLECULES = 'ALL_VOLUME_MOLECULES'
ALL_SURFACE_MOLECULES = 'ALL_SURFACE_MOLECULES'
DEFAULT_CHECKPOINTS_DIR = 'checkpoints'
DEFAULT_SEED_DIR_PREFIX = 'seed_'
DEFAULT_SEED_DIR_DIGITS = 5
DEFAULT_ITERATION_DIR_PREFIX = 'it_'
ID_INVALID = -1
NUMBER_OF_TRAINS_UNLIMITED = -1
TIME_INFINITY = 1e140
INT_UNSET = INT32_MAX
FLT_UNSET = FLT_MAX
RNG_SIZE = 256


class BaseChkptMol():
    def __init__(
            self,
            id : int,
            species : Species,
            diffusion_time : float,
            birthday : float,
            flags : int,
            unimol_rxn_time : float = None
        ):
        self.id = id
        self.species = species
        self.diffusion_time = diffusion_time
        self.birthday = birthday
        self.flags = flags
        self.unimol_rxn_time = unimol_rxn_time


class ChkptSurfMol():
    def __init__(
            self,
            pos : Vec2,
            orientation : Orientation,
            geometry_object : GeometryObject,
            wall_index : int,
            grid_tile_index : int,
            id : int,
            species : Species,
            diffusion_time : float,
            birthday : float,
            flags : int,
            unimol_rxn_time : float = None
        ):
        self.pos = pos
        self.orientation = orientation
        self.geometry_object = geometry_object
        self.wall_index = wall_index
        self.grid_tile_index = grid_tile_index
        self.id = id
        self.species = species
        self.diffusion_time = diffusion_time
        self.birthday = birthday
        self.flags = flags
        self.unimol_rxn_time = unimol_rxn_time


class ChkptVolMol():
    def __init__(
            self,
            pos : Vec3,
            id : int,
            species : Species,
            diffusion_time : float,
            birthday : float,
            flags : int,
            unimol_rxn_time : float = None
        ):
        self.pos = pos
        self.id = id
        self.species = species
        self.diffusion_time = diffusion_time
        self.birthday = birthday
        self.flags = flags
        self.unimol_rxn_time = unimol_rxn_time


class Color():
    def __init__(
            self,
            red : float = None,
            green : float = None,
            blue : float = None,
            alpha : float = 1,
            rgba : int = 0
        ):
        self.red = red
        self.green = green
        self.blue = blue
        self.alpha = alpha
        self.rgba = rgba


class Complex():
    def __init__(
            self,
            name : str = None,
            elementary_molecules : List[ElementaryMolecule] = None,
            orientation : Orientation = Orientation.DEFAULT,
            compartment_name : str = None
        ):
        self.name = name
        self.elementary_molecules = elementary_molecules
        self.orientation = orientation
        self.compartment_name = compartment_name


    def to_bngl_str(
            self,
        ) -> 'str':
        pass

    def as_species(
            self,
        ) -> 'Species':
        pass

class Component():
    def __init__(
            self,
            component_type : ComponentType,
            state : str = STATE_UNSET,
            bond : int = BOND_UNBOUND
        ):
        self.component_type = component_type
        self.state = state
        self.bond = bond


    def to_bngl_str(
            self,
        ) -> 'str':
        pass

class ComponentType():
    def __init__(
            self,
            name : str,
            states : List[str] = None
        ):
        self.name = name
        self.states = states


    def inst(
            self,
            state : str = STATE_UNSET,
            bond : int = BOND_UNBOUND
        ) -> 'Component':
        pass

    def to_bngl_str(
            self,
        ) -> 'str':
        pass

class Config():
    def __init__(
            self,
            seed : int = 1,
            time_step : float = 1e-6,
            use_bng_units : bool = False,
            surface_grid_density : float = 10000,
            interaction_radius : float = None,
            intermembrane_interaction_radius : float = None,
            vacancy_search_distance : float = 10,
            center_molecules_on_grid : bool = False,
            partition_dimension : float = 10,
            initial_partition_origin : List[float] = None,
            subpartition_dimension : float = 0.5,
            total_iterations : float = 1000000,
            check_overlapped_walls : bool = True,
            reaction_class_cleanup_periodicity : int = 500,
            species_cleanup_periodicity : int = 10000,
            molecules_order_random_shuffle_periodicity : int = 10000,
            sort_molecules : bool = False,
            memory_limit_gb : int = -1,
            initial_iteration : int = 0,
            initial_time : float = 0,
            initial_rng_state : RngState = None,
            append_to_count_output_data : bool = False,
            continue_after_sigalrm : bool = False
        ):
        self.seed = seed
        self.time_step = time_step
        self.use_bng_units = use_bng_units
        self.surface_grid_density = surface_grid_density
        self.interaction_radius = interaction_radius
        self.intermembrane_interaction_radius = intermembrane_interaction_radius
        self.vacancy_search_distance = vacancy_search_distance
        self.center_molecules_on_grid = center_molecules_on_grid
        self.partition_dimension = partition_dimension
        self.initial_partition_origin = initial_partition_origin
        self.subpartition_dimension = subpartition_dimension
        self.total_iterations = total_iterations
        self.check_overlapped_walls = check_overlapped_walls
        self.reaction_class_cleanup_periodicity = reaction_class_cleanup_periodicity
        self.species_cleanup_periodicity = species_cleanup_periodicity
        self.molecules_order_random_shuffle_periodicity = molecules_order_random_shuffle_periodicity
        self.sort_molecules = sort_molecules
        self.memory_limit_gb = memory_limit_gb
        self.initial_iteration = initial_iteration
        self.initial_time = initial_time
        self.initial_rng_state = initial_rng_state
        self.append_to_count_output_data = append_to_count_output_data
        self.continue_after_sigalrm = continue_after_sigalrm


class Count():
    def __init__(
            self,
            name : str = None,
            file_name : str = None,
            expression : CountTerm = None,
            multiplier : float = 1,
            every_n_timesteps : float = 1,
            output_format : CountOutputFormat = CountOutputFormat.AUTOMATIC_FROM_EXTENSION
        ):
        self.name = name
        self.file_name = file_name
        self.expression = expression
        self.multiplier = multiplier
        self.every_n_timesteps = every_n_timesteps
        self.output_format = output_format


    def get_current_value(
            self,
        ) -> 'float':
        pass

class CountTerm():
    def __init__(
            self,
            species_pattern : Complex = None,
            molecules_pattern : Complex = None,
            reaction_rule : ReactionRule = None,
            region : Region = None,
            node_type : ExprNodeType = ExprNodeType.LEAF,
            left_node : CountTerm = None,
            right_node : CountTerm = None,
            initial_reactions_count : int = 0
        ):
        self.species_pattern = species_pattern
        self.molecules_pattern = molecules_pattern
        self.reaction_rule = reaction_rule
        self.region = region
        self.node_type = node_type
        self.left_node = left_node
        self.right_node = right_node
        self.initial_reactions_count = initial_reactions_count


    def __add__(
            self,
            op2 : CountTerm
        ) -> 'CountTerm':
        pass

    def __sub__(
            self,
            op2 : CountTerm
        ) -> 'CountTerm':
        pass

class ElementaryMolecule():
    def __init__(
            self,
            elementary_molecule_type : ElementaryMoleculeType,
            components : List[Component] = None,
            compartment_name : str = None
        ):
        self.elementary_molecule_type = elementary_molecule_type
        self.components = components
        self.compartment_name = compartment_name


    def to_bngl_str(
            self,
            with_compartment : bool = True
        ) -> 'str':
        pass

class ElementaryMoleculeType():
    def __init__(
            self,
            name : str,
            components : List[ComponentType] = None,
            diffusion_constant_2d : float = None,
            diffusion_constant_3d : float = None,
            custom_time_step : float = None,
            custom_space_step : float = None,
            target_only : bool = False
        ):
        self.name = name
        self.components = components
        self.diffusion_constant_2d = diffusion_constant_2d
        self.diffusion_constant_3d = diffusion_constant_3d
        self.custom_time_step = custom_time_step
        self.custom_space_step = custom_space_step
        self.target_only = target_only


    def inst(
            self,
            components : List[Component] = None,
            compartment_name : str = None
        ) -> 'ElementaryMolecule':
        pass

    def to_bngl_str(
            self,
        ) -> 'str':
        pass

class GeometryObject():
    def __init__(
            self,
            name : str,
            vertex_list : List[List[float]],
            wall_list : List[List[int]],
            is_bngl_compartment : bool = False,
            surface_compartment_name : str = None,
            surface_regions : List[SurfaceRegion] = None,
            surface_class : SurfaceClass = None,
            initial_surface_releases : List[InitialSurfaceRelease] = None,
            initial_color : Color = None,
            node_type : RegionNodeType = RegionNodeType.UNSET,
            left_node : Region = None,
            right_node : Region = None
        ):
        self.name = name
        self.vertex_list = vertex_list
        self.wall_list = wall_list
        self.is_bngl_compartment = is_bngl_compartment
        self.surface_compartment_name = surface_compartment_name
        self.surface_regions = surface_regions
        self.surface_class = surface_class
        self.initial_surface_releases = initial_surface_releases
        self.initial_color = initial_color
        self.node_type = node_type
        self.left_node = left_node
        self.right_node = right_node


    def translate(
            self,
            move : List[float]
        ) -> None:
        pass

    def __add__(
            self,
            other : Region
        ) -> 'Region':
        pass

    def __sub__(
            self,
            other : Region
        ) -> 'Region':
        pass

    def __mul__(
            self,
            other : Region
        ) -> 'Region':
        pass

class InitialSurfaceRelease():
    def __init__(
            self,
            complex : Complex,
            number_to_release : int = None,
            density : float = None
        ):
        self.complex = complex
        self.number_to_release = number_to_release
        self.density = density


class Instantiation():
    def __init__(
            self,
            release_sites : List[ReleaseSite] = None,
            geometry_objects : List[GeometryObject] = None,
            checkpointed_molecules : List[BaseChkptMol] = None
        ):
        self.release_sites = release_sites
        self.geometry_objects = geometry_objects
        self.checkpointed_molecules = checkpointed_molecules


    def add_release_site(
            self,
            s : ReleaseSite
        ) -> None:
        pass

    def find_release_site(
            self,
            name : str
        ) -> 'ReleaseSite':
        pass

    def add_geometry_object(
            self,
            o : GeometryObject
        ) -> None:
        pass

    def find_geometry_object(
            self,
            name : str
        ) -> 'GeometryObject':
        pass

    def find_volume_compartment_object(
            self,
            name : str
        ) -> 'GeometryObject':
        pass

    def find_surface_compartment_object(
            self,
            name : str
        ) -> 'GeometryObject':
        pass

    def load_bngl_compartments_and_seed_species(
            self,
            file_name : str,
            default_release_region : Region = None,
            parameter_overrides : Dict[str, float] = None
        ) -> None:
        pass

class Introspection():
    def __init__(
            self,
        ):
        pass

    def get_molecule_ids(
            self,
            pattern : Complex = None
        ) -> 'List[int]':
        pass

    def get_molecule(
            self,
            id : int
        ) -> 'Molecule':
        pass

    def get_species_name(
            self,
            species_id : int
        ) -> 'str':
        pass

    def get_vertex(
            self,
            object : GeometryObject,
            vertex_index : int
        ) -> 'List[float]':
        pass

    def get_wall(
            self,
            object : GeometryObject,
            wall_index : int
        ) -> 'Wall':
        pass

    def get_vertex_unit_normal(
            self,
            object : GeometryObject,
            vertex_index : int
        ) -> 'List[float]':
        pass

    def get_wall_unit_normal(
            self,
            object : GeometryObject,
            wall_index : int
        ) -> 'List[float]':
        pass

    def get_wall_color(
            self,
            object : GeometryObject,
            wall_index : int
        ) -> 'Color':
        pass

    def set_wall_color(
            self,
            object : GeometryObject,
            wall_index : int,
            color : Color
        ) -> None:
        pass

class Model():
    def __init__(
            self,
            config : Config = Config(),
            warnings : Warnings = Warnings(),
            notifications : Notifications = Notifications(),
            species : List[Species] = None,
            reaction_rules : List[ReactionRule] = None,
            surface_classes : List[SurfaceClass] = None,
            elementary_molecule_types : List[ElementaryMoleculeType] = None,
            release_sites : List[ReleaseSite] = None,
            geometry_objects : List[GeometryObject] = None,
            checkpointed_molecules : List[BaseChkptMol] = None,
            viz_outputs : List[VizOutput] = None,
            counts : List[Count] = None
        ):
        self.config = config
        self.warnings = warnings
        self.notifications = notifications
        self.species = species
        self.reaction_rules = reaction_rules
        self.surface_classes = surface_classes
        self.elementary_molecule_types = elementary_molecule_types
        self.release_sites = release_sites
        self.geometry_objects = geometry_objects
        self.checkpointed_molecules = checkpointed_molecules
        self.viz_outputs = viz_outputs
        self.counts = counts


    def initialize(
            self,
            print_copyright : bool = True
        ) -> None:
        pass

    def run_iterations(
            self,
            iterations : float
        ) -> 'int':
        pass

    def end_simulation(
            self,
            print_final_report : bool = True
        ) -> None:
        pass

    def add_subsystem(
            self,
            subsystem : Subsystem
        ) -> None:
        pass

    def add_instantiation(
            self,
            instantiation : Instantiation
        ) -> None:
        pass

    def add_observables(
            self,
            observables : Observables
        ) -> None:
        pass

    def dump_internal_state(
            self,
            with_geometry : bool = False
        ) -> None:
        pass

    def export_data_model(
            self,
            file : str = None
        ) -> None:
        pass

    def export_viz_data_model(
            self,
            file : str = None
        ) -> None:
        pass

    def export_geometry(
            self,
            output_files_prefix : str = None
        ) -> None:
        pass

    def release_molecules(
            self,
            release_site : ReleaseSite
        ) -> None:
        pass

    def run_reaction(
            self,
            reaction_rule : ReactionRule,
            reactant_ids : List[int],
            time : float
        ) -> 'List[int]':
        pass

    def add_vertex_move(
            self,
            object : GeometryObject,
            vertex_index : int,
            displacement : List[float]
        ) -> None:
        pass

    def apply_vertex_moves(
            self,
            collect_wall_wall_hits : bool = False,
            randomize_order : bool = True
        ) -> 'List[WallWallHitInfo]':
        pass

    def pair_molecules(
            self,
            id1 : int,
            id2 : int
        ) -> None:
        pass

    def unpair_molecules(
            self,
            id1 : int,
            id2 : int
        ) -> None:
        pass

    def get_paired_molecule(
            self,
            id : int
        ) -> 'int':
        pass

    def get_paired_molecules(
            self,
        ) -> 'Dict[uint32, uint32]':
        pass

    def register_mol_wall_hit_callback(
            self,
            function : Callable, # std::function<void(std::shared_ptr<MolWallHitInfo>, py::object)>,
            context : Any, # py::object,
            object : GeometryObject = None,
            species : Species = None
        ) -> None:
        pass

    def register_reaction_callback(
            self,
            function : Callable, # std::function<bool(std::shared_ptr<ReactionInfo>, py::object)>,
            context : Any, # py::object,
            reaction_rule : ReactionRule
        ) -> None:
        pass

    def load_bngl(
            self,
            file_name : str,
            observables_path_or_file : str = None,
            default_release_region : Region = None,
            parameter_overrides : Dict[str, float] = None,
            observables_output_format : CountOutputFormat = CountOutputFormat.AUTOMATIC_FROM_EXTENSION
        ) -> None:
        pass

    def export_to_bngl(
            self,
            file_name : str,
            simulation_method : BNGSimulationMethod = BNGSimulationMethod.ODE
        ) -> None:
        pass

    def save_checkpoint(
            self,
            custom_dir : str = None
        ) -> None:
        pass

    def schedule_checkpoint(
            self,
            iteration : int = 0,
            continue_simulation : bool = False,
            custom_dir : str = None
        ) -> None:
        pass

    def add_species(
            self,
            s : Species
        ) -> None:
        pass

    def find_species(
            self,
            name : str
        ) -> 'Species':
        pass

    def add_reaction_rule(
            self,
            r : ReactionRule
        ) -> None:
        pass

    def find_reaction_rule(
            self,
            name : str
        ) -> 'ReactionRule':
        pass

    def add_surface_class(
            self,
            sc : SurfaceClass
        ) -> None:
        pass

    def find_surface_class(
            self,
            name : str
        ) -> 'SurfaceClass':
        pass

    def add_elementary_molecule_type(
            self,
            mt : ElementaryMoleculeType
        ) -> None:
        pass

    def find_elementary_molecule_type(
            self,
            name : str
        ) -> 'ElementaryMoleculeType':
        pass

    def load_bngl_molecule_types_and_reaction_rules(
            self,
            file_name : str,
            parameter_overrides : Dict[str, float] = None
        ) -> None:
        pass

    def add_release_site(
            self,
            s : ReleaseSite
        ) -> None:
        pass

    def find_release_site(
            self,
            name : str
        ) -> 'ReleaseSite':
        pass

    def add_geometry_object(
            self,
            o : GeometryObject
        ) -> None:
        pass

    def find_geometry_object(
            self,
            name : str
        ) -> 'GeometryObject':
        pass

    def find_volume_compartment_object(
            self,
            name : str
        ) -> 'GeometryObject':
        pass

    def find_surface_compartment_object(
            self,
            name : str
        ) -> 'GeometryObject':
        pass

    def load_bngl_compartments_and_seed_species(
            self,
            file_name : str,
            default_release_region : Region = None,
            parameter_overrides : Dict[str, float] = None
        ) -> None:
        pass

    def add_viz_output(
            self,
            viz_output : VizOutput
        ) -> None:
        pass

    def add_count(
            self,
            count : Count
        ) -> None:
        pass

    def find_count(
            self,
            name : str
        ) -> 'Count':
        pass

    def load_bngl_observables(
            self,
            file_name : str,
            observables_path_or_file : str = None,
            parameter_overrides : Dict[str, float] = None,
            observables_output_format : CountOutputFormat = CountOutputFormat.AUTOMATIC_FROM_EXTENSION
        ) -> None:
        pass

    def get_molecule_ids(
            self,
            pattern : Complex = None
        ) -> 'List[int]':
        pass

    def get_molecule(
            self,
            id : int
        ) -> 'Molecule':
        pass

    def get_species_name(
            self,
            species_id : int
        ) -> 'str':
        pass

    def get_vertex(
            self,
            object : GeometryObject,
            vertex_index : int
        ) -> 'List[float]':
        pass

    def get_wall(
            self,
            object : GeometryObject,
            wall_index : int
        ) -> 'Wall':
        pass

    def get_vertex_unit_normal(
            self,
            object : GeometryObject,
            vertex_index : int
        ) -> 'List[float]':
        pass

    def get_wall_unit_normal(
            self,
            object : GeometryObject,
            wall_index : int
        ) -> 'List[float]':
        pass

    def get_wall_color(
            self,
            object : GeometryObject,
            wall_index : int
        ) -> 'Color':
        pass

    def set_wall_color(
            self,
            object : GeometryObject,
            wall_index : int,
            color : Color
        ) -> None:
        pass

class MolWallHitInfo():
    def __init__(
            self,
            molecule_id : int,
            geometry_object : GeometryObject,
            wall_index : int,
            time : float,
            pos3d : List[float],
            time_before_hit : float,
            pos3d_before_hit : List[float]
        ):
        self.molecule_id = molecule_id
        self.geometry_object = geometry_object
        self.wall_index = wall_index
        self.time = time
        self.pos3d = pos3d
        self.time_before_hit = time_before_hit
        self.pos3d_before_hit = pos3d_before_hit


class Molecule():
    def __init__(
            self,
            id : int = ID_INVALID,
            type : MoleculeType = MoleculeType.UNSET,
            species_id : int = ID_INVALID,
            pos3d : List[float] = None,
            orientation : Orientation = Orientation.NOT_SET,
            pos2d : List[float] = None,
            geometry_object : GeometryObject = None,
            wall_index : int = -1
        ):
        self.id = id
        self.type = type
        self.species_id = species_id
        self.pos3d = pos3d
        self.orientation = orientation
        self.pos2d = pos2d
        self.geometry_object = geometry_object
        self.wall_index = wall_index


    def remove(
            self,
        ) -> None:
        pass

class MoleculeReleaseInfo():
    def __init__(
            self,
            complex : Complex,
            location : List[float]
        ):
        self.complex = complex
        self.location = location


class Notifications():
    def __init__(
            self,
            bng_verbosity_level : int = 0,
            rxn_and_species_report : bool = False,
            simulation_stats_every_n_iterations : int = 0,
            rxn_probability_changed : bool = True,
            iteration_report : bool = True,
            wall_overlap_report : bool = False
        ):
        self.bng_verbosity_level = bng_verbosity_level
        self.rxn_and_species_report = rxn_and_species_report
        self.simulation_stats_every_n_iterations = simulation_stats_every_n_iterations
        self.rxn_probability_changed = rxn_probability_changed
        self.iteration_report = iteration_report
        self.wall_overlap_report = wall_overlap_report


class Observables():
    def __init__(
            self,
            viz_outputs : List[VizOutput] = None,
            counts : List[Count] = None
        ):
        self.viz_outputs = viz_outputs
        self.counts = counts


    def add_viz_output(
            self,
            viz_output : VizOutput
        ) -> None:
        pass

    def add_count(
            self,
            count : Count
        ) -> None:
        pass

    def find_count(
            self,
            name : str
        ) -> 'Count':
        pass

    def load_bngl_observables(
            self,
            file_name : str,
            observables_path_or_file : str = None,
            parameter_overrides : Dict[str, float] = None,
            observables_output_format : CountOutputFormat = CountOutputFormat.AUTOMATIC_FROM_EXTENSION
        ) -> None:
        pass

class ReactionInfo():
    def __init__(
            self,
            type : ReactionType,
            reactant_ids : List[int],
            product_ids : List[int],
            reaction_rule : ReactionRule,
            time : float,
            pos3d : List[float],
            geometry_object : GeometryObject = None,
            wall_index : int = -1,
            pos2d : List[float] = None
        ):
        self.type = type
        self.reactant_ids = reactant_ids
        self.product_ids = product_ids
        self.reaction_rule = reaction_rule
        self.time = time
        self.pos3d = pos3d
        self.geometry_object = geometry_object
        self.wall_index = wall_index
        self.pos2d = pos2d


class ReactionRule():
    def __init__(
            self,
            name : str = None,
            reactants : List[Complex] = None,
            products : List[Complex] = None,
            fwd_rate : float = None,
            rev_name : str = None,
            rev_rate : float = None,
            variable_rate : List[List[float]] = None,
            is_intermembrane_surface_reaction : bool = False
        ):
        self.name = name
        self.reactants = reactants
        self.products = products
        self.fwd_rate = fwd_rate
        self.rev_name = rev_name
        self.rev_rate = rev_rate
        self.variable_rate = variable_rate
        self.is_intermembrane_surface_reaction = is_intermembrane_surface_reaction


    def to_bngl_str(
            self,
        ) -> 'str':
        pass

class Region():
    def __init__(
            self,
            node_type : RegionNodeType = RegionNodeType.UNSET,
            left_node : Region = None,
            right_node : Region = None
        ):
        self.node_type = node_type
        self.left_node = left_node
        self.right_node = right_node


    def __add__(
            self,
            other : Region
        ) -> 'Region':
        pass

    def __sub__(
            self,
            other : Region
        ) -> 'Region':
        pass

    def __mul__(
            self,
            other : Region
        ) -> 'Region':
        pass

class ReleasePattern():
    def __init__(
            self,
            name : str = None,
            release_interval : float = TIME_INFINITY,
            train_duration : float = TIME_INFINITY,
            train_interval : float = TIME_INFINITY,
            number_of_trains : int = 1
        ):
        self.name = name
        self.release_interval = release_interval
        self.train_duration = train_duration
        self.train_interval = train_interval
        self.number_of_trains = number_of_trains


class ReleaseSite():
    def __init__(
            self,
            name : str,
            complex : Complex = None,
            molecule_list : List[MoleculeReleaseInfo] = None,
            release_time : float = 0,
            release_pattern : ReleasePattern = None,
            shape : Shape = Shape.UNSET,
            region : Region = None,
            location : List[float] = None,
            site_diameter : float = 0,
            site_radius : float = None,
            number_to_release : float = None,
            density : float = None,
            concentration : float = None,
            release_probability : float = 1
        ):
        self.name = name
        self.complex = complex
        self.molecule_list = molecule_list
        self.release_time = release_time
        self.release_pattern = release_pattern
        self.shape = shape
        self.region = region
        self.location = location
        self.site_diameter = site_diameter
        self.site_radius = site_radius
        self.number_to_release = number_to_release
        self.density = density
        self.concentration = concentration
        self.release_probability = release_probability


class RngState():
    def __init__(
            self,
            randcnt : int,
            aa : int,
            bb : int,
            cc : int,
            randslr : List[int],
            mm : List[int],
            rngblocks : int
        ):
        self.randcnt = randcnt
        self.aa = aa
        self.bb = bb
        self.cc = cc
        self.randslr = randslr
        self.mm = mm
        self.rngblocks = rngblocks


class Species():
    def __init__(
            self,
            name : str = None,
            diffusion_constant_2d : float = None,
            diffusion_constant_3d : float = None,
            custom_time_step : float = None,
            custom_space_step : float = None,
            target_only : bool = False,
            elementary_molecules : List[ElementaryMolecule] = None,
            orientation : Orientation = Orientation.DEFAULT,
            compartment_name : str = None
        ):
        self.name = name
        self.diffusion_constant_2d = diffusion_constant_2d
        self.diffusion_constant_3d = diffusion_constant_3d
        self.custom_time_step = custom_time_step
        self.custom_space_step = custom_space_step
        self.target_only = target_only
        self.name = name
        self.elementary_molecules = elementary_molecules
        self.orientation = orientation
        self.compartment_name = compartment_name


    def inst(
            self,
            orientation : Orientation = Orientation.DEFAULT,
            compartment_name : str = None
        ) -> 'Complex':
        pass

    def to_bngl_str(
            self,
        ) -> 'str':
        pass

    def as_species(
            self,
        ) -> 'Species':
        pass

class Subsystem():
    def __init__(
            self,
            species : List[Species] = None,
            reaction_rules : List[ReactionRule] = None,
            surface_classes : List[SurfaceClass] = None,
            elementary_molecule_types : List[ElementaryMoleculeType] = None
        ):
        self.species = species
        self.reaction_rules = reaction_rules
        self.surface_classes = surface_classes
        self.elementary_molecule_types = elementary_molecule_types


    def add_species(
            self,
            s : Species
        ) -> None:
        pass

    def find_species(
            self,
            name : str
        ) -> 'Species':
        pass

    def add_reaction_rule(
            self,
            r : ReactionRule
        ) -> None:
        pass

    def find_reaction_rule(
            self,
            name : str
        ) -> 'ReactionRule':
        pass

    def add_surface_class(
            self,
            sc : SurfaceClass
        ) -> None:
        pass

    def find_surface_class(
            self,
            name : str
        ) -> 'SurfaceClass':
        pass

    def add_elementary_molecule_type(
            self,
            mt : ElementaryMoleculeType
        ) -> None:
        pass

    def find_elementary_molecule_type(
            self,
            name : str
        ) -> 'ElementaryMoleculeType':
        pass

    def load_bngl_molecule_types_and_reaction_rules(
            self,
            file_name : str,
            parameter_overrides : Dict[str, float] = None
        ) -> None:
        pass

class SurfaceClass():
    def __init__(
            self,
            name : str,
            properties : List[SurfaceProperty] = None,
            type : SurfacePropertyType = SurfacePropertyType.UNSET,
            affected_complex_pattern : Complex = None,
            concentration : float = None
        ):
        self.name = name
        self.properties = properties
        self.type = type
        self.affected_complex_pattern = affected_complex_pattern
        self.concentration = concentration


class SurfaceProperty():
    def __init__(
            self,
            type : SurfacePropertyType = SurfacePropertyType.UNSET,
            affected_complex_pattern : Complex = None,
            concentration : float = None
        ):
        self.type = type
        self.affected_complex_pattern = affected_complex_pattern
        self.concentration = concentration


class SurfaceRegion():
    def __init__(
            self,
            name : str,
            wall_indices : List[int],
            surface_class : SurfaceClass = None,
            initial_surface_releases : List[InitialSurfaceRelease] = None,
            initial_color : Color = None,
            node_type : RegionNodeType = RegionNodeType.UNSET,
            left_node : Region = None,
            right_node : Region = None
        ):
        self.name = name
        self.wall_indices = wall_indices
        self.surface_class = surface_class
        self.initial_surface_releases = initial_surface_releases
        self.initial_color = initial_color
        self.node_type = node_type
        self.left_node = left_node
        self.right_node = right_node


    def __add__(
            self,
            other : Region
        ) -> 'Region':
        pass

    def __sub__(
            self,
            other : Region
        ) -> 'Region':
        pass

    def __mul__(
            self,
            other : Region
        ) -> 'Region':
        pass

class VizOutput():
    def __init__(
            self,
            output_files_prefix : str = None,
            species_list : List[Species] = None,
            mode : VizMode = VizMode.ASCII,
            every_n_timesteps : float = 1
        ):
        self.output_files_prefix = output_files_prefix
        self.species_list = species_list
        self.mode = mode
        self.every_n_timesteps = every_n_timesteps


class Wall():
    def __init__(
            self,
            geometry_object : GeometryObject,
            wall_index : int,
            vertices : List[List[float]],
            area : float,
            unit_normal : List[float],
            is_movable : bool = True
        ):
        self.geometry_object = geometry_object
        self.wall_index = wall_index
        self.vertices = vertices
        self.area = area
        self.unit_normal = unit_normal
        self.is_movable = is_movable


class WallWallHitInfo():
    def __init__(
            self,
            wall1 : Wall,
            wall2 : Wall
        ):
        self.wall1 = wall1
        self.wall2 = wall2


class Warnings():
    def __init__(
            self,
            high_reaction_probability : WarningLevel = WarningLevel.IGNORE,
            molecule_placement_failure : WarningLevel = WarningLevel.ERROR
        ):
        self.high_reaction_probability = high_reaction_probability
        self.molecule_placement_failure = molecule_placement_failure


class bngl_utils():
    def __init__(
            self,
        ):
        pass

    def load_bngl_parameters(
            self,
            file_name : str,
            parameter_overrides : Dict[str, float] = None
        ) -> 'Dict[str, float]':
        pass

class data_utils():
    def __init__(
            self,
        ):
        pass

    def load_dat_file(
            self,
            file_name : str
        ) -> 'List[List[float]]':
        pass

class geometry_utils():
    def __init__(
            self,
        ):
        pass

    def create_box(
            self,
            name : str,
            edge_dimension : float = None,
            xyz_dimensions : List[float] = None
        ) -> 'GeometryObject':
        pass

    def create_icosphere(
            self,
            name : str,
            radius : float,
            subdivisions : int
        ) -> 'GeometryObject':
        pass

    def validate_volumetric_mesh(
            self,
            model : Model,
            geometry_object : GeometryObject
        ) -> None:
        pass

class run_utils():
    def __init__(
            self,
        ):
        pass

    def get_last_checkpoint_dir(
            self,
            seed : int
        ) -> 'str':
        pass

    def remove_cwd(
            self,
            paths : List[str]
        ) -> 'List[str]':
        pass

AllMolecules = Species('ALL_MOLECULES')
AllVolumeMolecules = Species('ALL_VOLUME_MOLECULES')
AllSurfaceMolecules = Species('ALL_SURFACE_MOLECULES')