Sign upLogin

GillesPy2/GillesPy2

View on GitHub
Star
gillespy2/core/model.py

Summary

Maintainability
F
4 days
Test Coverage
D
66%

Function to_model has a Cognitive Complexity of 60 (exceeds 5 allowed). Consider refactoring.
Open

    def to_model(self, name):
        """ Instantiates a Model object from a StochMLDocument. """

        # Empty model
        model = Model(name=name)
Severity: Minor
Found in gillespy2/core/model.py - About 1 day to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Cyclomatic complexity is too high in method to_model. (32)
Open

    def to_model(self, name):
        """ Instantiates a Model object from a StochMLDocument. """

        # Empty model
        model = Model(name=name)
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method add. (23)
Open

    def add(self, components):
        """
        Adds a component, or list of components to the model. If a list is provided, Species
        and Parameters are added before other components.  Lists may contain any combination
        of accepted types other than lists and do not need to be in any particular order.
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function __str__ has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
Open

    def __str__(self):
        divider = '\n**********\n'

        def decorate(header):
            return '\n' + divider + header + divider
Severity: Minor
Found in gillespy2/core/model.py - About 3 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Cyclomatic complexity is too high in method __str__. (17)
Open

    def __str__(self):
        divider = '\n**********\n'

        def decorate(header):
            return '\n' + divider + header + divider
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method make_translation_table. (17)
Open

    def make_translation_table(self):
        species = self.listOfSpecies.values()
        reactions = self.listOfReactions.values()
        parameters = self.listOfParameters.values()
        assignments = self.listOfAssignmentRules.values()
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method get_best_solver. (15)
Open

    def get_best_solver(self):
        """
        Finds best solver for the users simulation. Currently, AssignmentRules, RateRules, FunctionDefinitions,
        Events, and Species with a dynamic, or continuous population must use the TauHybridSolver.
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method get_best_solver_algo. (14)
Open

    def get_best_solver_algo(self, algorithm):
        """
        If user has specified a particular algorithm, we return either the Python or C++ version of that algorithm
        """
        from gillespy2.solvers.cpp.build.build_engine import BuildEngine # pylint: disable=import-outside-toplevel
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method add_rate_rule. (13)
Open

    def add_rate_rule(self, rate_rule):
        """
        Adds a rate rule, or list of rate rules to the model.

        :param rate_rule: The rate rule or list of rate rules to be added to the model object.
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method _problem_with_name. (12)
Open

    def _problem_with_name(self, name):
        if name in Model.reserved_names:
            names = Model.reserved_names
            raise ModelError(
                f'Name "{name}" is unavailable. It is reserved for internal GillesPy use. Reserved Names: ({names}).'
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method run. (11)
Open

    def run(self, solver=None, timeout=0, t=None, increment=None, algorithm=None, **solver_args):
        """
        Function calling simulation of the model. There are a number of
        parameters to be set here.
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method _resolve_reaction. (10)
Open

    def _resolve_reaction(self, reaction):
        try:
            reaction.validate()

            # If the rate parameter exists in the reaction, confirm that it is a part of the model
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function add has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
Open

    def add(self, components):
        """
        Adds a component, or list of components to the model. If a list is provided, Species
        and Parameters are added before other components.  Lists may contain any combination
        of accepted types other than lists and do not need to be in any particular order.
Severity: Minor
Found in gillespy2/core/model.py - About 2 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Cyclomatic complexity is too high in method get_element. (9)
Open

    def get_element(self, name):
        """
        Get a model element specified by name.

        :param name: Name of the element to be returned.
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Cyclomatic complexity is too high in method add_assignment_rule. (9)
Open

    def add_assignment_rule(self, assignment_rule):
        """
        Add an assignment rule, or list of assignment rules to the model.

        :param assignment_rules: The assignment rule or list of assignment rules to be added to the model object.
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function add_rate_rule has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
Open

    def add_rate_rule(self, rate_rule):
        """
        Adds a rate rule, or list of rate rules to the model.

        :param rate_rule: The rate rule or list of rate rules to be added to the model object.
Severity: Minor
Found in gillespy2/core/model.py - About 2 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function get_best_solver has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
Open

    def get_best_solver(self):
        """
        Finds best solver for the users simulation. Currently, AssignmentRules, RateRules, FunctionDefinitions,
        Events, and Species with a dynamic, or continuous population must use the TauHybridSolver.
Severity: Minor
Found in gillespy2/core/model.py - About 1 hr to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function get_best_solver_algo has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
Open

    def get_best_solver_algo(self, algorithm):
        """
        If user has specified a particular algorithm, we return either the Python or C++ version of that algorithm
        """
        from gillespy2.solvers.cpp.build.build_engine import BuildEngine # pylint: disable=import-outside-toplevel
Severity: Minor
Found in gillespy2/core/model.py - About 1 hr to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Cyclomatic complexity is too high in method add_species. (6)
Open

    def add_species(self, species):
        """
        Adds a species, or list of species to the model.

        :param species: The species or list of species to be added to the model object
Severity: Minor
Found in gillespy2/core/model.py by radon

Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

Source: http://radon.readthedocs.org/en/latest/intro.html

Function _resolve_reaction has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
Open

    def _resolve_reaction(self, reaction):
        try:
            reaction.validate()

            # If the rate parameter exists in the reaction, confirm that it is a part of the model
Severity: Minor
Found in gillespy2/core/model.py - About 1 hr to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Consider simplifying this complex logical expression.
Open

        if isinstance(components, list):
            p_types = (Species, Parameter, FunctionDefinition, TimeSpan)
            p_names = (p_type.__name__ for p_type in p_types)

            others = []
Severity: Critical
Found in gillespy2/core/model.py - About 1 hr to fix

    Function run has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
    Open

        def run(self, solver=None, timeout=0, t=None, increment=None, algorithm=None, **solver_args):
        """
        Function calling simulation of the model. There are a number of
        parameters to be set here.
    Severity: Minor
    Found in gillespy2/core/model.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _problem_with_name has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
    Open

        def _problem_with_name(self, name):
        if name in Model.reserved_names:
            names = Model.reserved_names
            raise ModelError(
                f'Name "{name}" is unavailable. It is reserved for internal GillesPy use. Reserved Names: ({names}).'
    Severity: Minor
    Found in gillespy2/core/model.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function add_assignment_rule has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
    Open

        def add_assignment_rule(self, assignment_rule):
        """
        Add an assignment rule, or list of assignment rules to the model.

        :param assignment_rules: The assignment rule or list of assignment rules to be added to the model object.
    Severity: Minor
    Found in gillespy2/core/model.py - About 55 mins to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function get_element has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
    Open

        def get_element(self, name):
        """
        Get a model element specified by name.

        :param name: Name of the element to be returned.
    Severity: Minor
    Found in gillespy2/core/model.py - About 45 mins to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function add_species has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
    Open

        def add_species(self, species):
        """
        Adds a species, or list of species to the model.

        :param species: The species or list of species to be added to the model object
    Severity: Minor
    Found in gillespy2/core/model.py - About 35 mins to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _resolve_event has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
    Open

        def _resolve_event(self, event):
        def validate(event):
            from gillespy2.core.gillespyError import EventError # pylint: disable=import-outside-toplevel
            if event.trigger is None or not hasattr(event.trigger, 'expression'):
                raise EventError('An Event must contain a valid trigger.')
    Severity: Minor
    Found in gillespy2/core/model.py - About 35 mins to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Avoid too many return statements within this function.
    Open

                return self.get_event(name)
    Severity: Major
    Found in gillespy2/core/model.py - About 30 mins to fix

      Avoid too many return statements within this function.
      Open

                  return TauHybridSolver
      Severity: Major
      Found in gillespy2/core/model.py - About 30 mins to fix

        Avoid too many return statements within this function.
        Open

                    return CLESolver
        Severity: Major
        Found in gillespy2/core/model.py - About 30 mins to fix

          Avoid too many return statements within this function.
          Open

                      return self.get_rate_rule(name)
          Severity: Major
          Found in gillespy2/core/model.py - About 30 mins to fix

            Avoid too many return statements within this function.
            Open

                        return self.get_assignment_rule(name)
            Severity: Major
            Found in gillespy2/core/model.py - About 30 mins to fix

              Avoid too many return statements within this function.
              Open

                              return ODECSolver
              Severity: Major
              Found in gillespy2/core/model.py - About 30 mins to fix

                Avoid too many return statements within this function.
                Open

                            return self.get_function_definition(name)
                Severity: Major
                Found in gillespy2/core/model.py - About 30 mins to fix

                  Avoid too many return statements within this function.
                  Open

                                  return TauHybridCSolver
                  Severity: Major
                  Found in gillespy2/core/model.py - About 30 mins to fix

                    Avoid too many return statements within this function.
                    Open

                                return ODESolver
                    Severity: Major
                    Found in gillespy2/core/model.py - About 30 mins to fix

                      Function _resolve_rule has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                      Open

                          def _resolve_rule(self, rule):
        def validate(rule):
            from gillespy2.core.gillespyError import RateRuleError, AssignmentRuleError # pylint: disable=import-outside-toplevel
            errors = {"RateRule": RateRuleError, "AssignmentRule": AssignmentRuleError}
            error_class = errors[type(rule).__name__]
                      Severity: Minor
                      Found in gillespy2/core/model.py - About 25 mins to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function __init__ has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                      Open

                          def __init__(self, name="", population=True, volume=1.0, tspan=None, annotation="model"):
        """ Create an empty model. """

        # The name that the model is referenced by (should be a String)
        self.name = name
                      Severity: Minor
                      Found in gillespy2/core/model.py - About 25 mins to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function compile_prep has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                      Open

                          def compile_prep(self):
        """
        Prepare the model for export or simulation.
        """
        for _, species in self.listOfSpecies.items():
                      Severity: Minor
                      Found in gillespy2/core/model.py - About 25 mins to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Line too long (87 > 79 characters)
                      Open

                                  errors = {"RateRule": RateRuleError, "AssignmentRule": AssignmentRuleError}
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                              :returns: A dict of all species in the model, in the form: {name : species object}.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (100 > 79 characters)
                      Open

                              from gillespy2.stochss.StochSSexport import export # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (92 > 79 characters)
                      Open

                              and Parameters are added before other components.  Lists may contain any combination
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (90 > 79 characters)
                      Open

                              elif isinstance(components, Event) or type(components).__name__ == Event.__name__:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (98 > 79 characters)
                      Open

                              elif isinstance(components, Parameter) or type(components).__name__ == Parameter.__name__:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                              :returns: the dictionary mapping user species names to their internal GillesPy notation.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                              :returns: A parameter or list of Parameters that were added to the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (95 > 79 characters)
                      Open

                              from gillespy2.sbml.SBMLimport import convert # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                              raise ImportError('StochSS export conversion not imported successfully') from err
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (90 > 79 characters)
                      Open

                          :param population: The type of model being described. A discrete stochastic model is a
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                          from gillespy2.core import log # pylint:disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (129 > 79 characters)
                      Open

                                  from gillespy2.core.gillespyError import RateRuleError, AssignmentRuleError # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (85 > 79 characters)
                      Open

                              :rtype: Species, Parameters, Reactions, Events, RateRules, AssignmentRules, \
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (87 > 79 characters)
                      Open

                                  self._listOfParameters[parameters.name] = f'P{len(self._listOfParameters)}'
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (93 > 79 characters)
                      Open

                              :raises ModelError: If an invalid reaction is provided or if Reaction.validate fails.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (84 > 79 characters)
                      Open

                              windows_space = platform.system() == "Windows" and " " in gillespy2.__file__
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                              from gillespy2.sbml.SBMLimport import convert # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (94 > 79 characters)
                      Open

                              from gillespy2.sbml.SBMLexport import export # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                                          "Note: concentration models may only be simulated deterministically."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (90 > 79 characters)
                      Open

                                  name = rule.variable if isinstance(rule.variable, str) else rule.variable.name
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (84 > 79 characters)
                      Open

                                      f"Could not add/resolve rate_rule: {rule.name}, Reason given: {err}"
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                              :param components: The component or list of components to be added the the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                              :type components: Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, \
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (94 > 79 characters)
                      Open

                              elif isinstance(components, Species) or type(components).__name__ == Species.__name__:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (82 > 79 characters)
                      Open

                                      self._listOfSpecies[species.name] = f'S{len(self._listOfSpecies)}'
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (104 > 79 characters)
                      Open

                              Generate a dictionary mapping user chosen species names to simplified formats which will be used
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (106 > 79 characters)
                      Open

                              Generate a dictionary mapping user chosen parameter names to simplified formats which will be used
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                          :param gillespy_model: If desired, the SBML model may be added to an existing GillesPy model
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (86 > 79 characters)
                      Open

                                  raise ModelError(f"{self.name} does not contain a reaction named {name}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (86 > 79 characters)
                      Open

                              raise ImportError('SBML export conversion not imported successfully') from err
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                              from gillespy2.stochss.StochSSexport import export # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (104 > 79 characters)
                      Open

                                          f'Name "{name}" is unavailable. Names must not contain special characters: {chars}.'
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (105 > 79 characters)
                      Open

                                  from gillespy2.core.gillespyError import EventError # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                              elif isinstance(parameters, Parameter) or type(parameters).__name__ == 'Parameter':
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (87 > 79 characters)
                      Open

                              elif isinstance(reactions, Reaction) or type(reactions).__name__ == "Reaction":
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                              from gillespy2.sbml.SBMLexport import export # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (87 > 79 characters)
                      Open

                                  # Confirm that the variable in the event assignments are part of the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (83 > 79 characters)
                      Open

                                  rr_vars = [r_rule.variable for r_rule in self.listOfRateRules.values()]
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                          return export(gillespy_model, path=filename, return_stochss_model=return_stochss_model)
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                          :param volume: The volume of the system matters when converting to from population to
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (94 > 79 characters)
                      Open

                                  raise ModelError(f'Name "{name}" is unavailable. An event with that name exists.')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                                  raise ModelError(f'Name "{name}" is unavailable. A rate rule with that name exists.')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (104 > 79 characters)
                      Open

                                  raise ModelError(f'Name "{name}" is unavailable. An assignment rule with that name exists.')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (92 > 79 characters)
                      Open

                              Adds a component, or list of components to the model. If a list is provided, Species
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                                      if isinstance(component, p_types) or type(component).__name__ in p_names:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                              elif isinstance(components, TimeSpan) or type(components).__name__ == TimeSpan.__name__:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (80 > 79 characters)
                      Open

                                      f"{self.name} does not contain an assignment rule named {name}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (118 > 79 characters)
                      Open

                                          "Concentration models account for volume implicitly, explicit volume definition is not required. "
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                  from gillespy2.core.gillespyError import EventError # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      At least two spaces before inline comment
                      Open

                                  from gillespy2.core.gillespyError import RateRuleError, AssignmentRuleError # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (87 > 79 characters)
                      Open

                              :rtype: Species, Parameters, Reactions, Events, Rate Rules, Assignment Rules, \
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (87 > 79 characters)
                      Open

                                  raise ModelError(f"{self.name} does not contain a parameter named {name}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                                          raise ModelError("RateRules can not target discrete species")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Multiple spaces after operator
                      Open

                          (model,errs) =  convert(
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Avoid extraneous whitespace around an operator.

                      Okay: a = 12 + 3
E221: a = 4  + 5
E222: a = 4 +  5
E223: a = 4\t+ 5
E224: a = 4 +\t5

                      Line too long (81 > 79 characters)
                      Open

                                      f"Could not add/resolve event: {event.name}, Reason given: {err}"
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (110 > 79 characters)
                      Open

                                      raise error_class('A GillesPy2 Rate/Assignment Rule must be associated with a valid variable')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (101 > 79 characters)
                      Open

                                  errmsg = f"reactions must be of type Reaction or list of Reaction not {type(reactions)}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Missing whitespace after ','
                      Open

                          (model,errs) =  convert(
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Each comma, semicolon or colon should be followed by whitespace.

                      Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                      Line too long (107 > 79 characters)
                      Open

                                  raise ModelError(f'Name "{name}" is unavailable. A function definition with that name exists.')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (112 > 79 characters)
                      Open

                                  raise ModelError(f"Could not add/resolve parameter: {parameter.name}, Reason given: {err}") from err
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                              elif isinstance(components, RateRule) or type(components).__name__ == RateRule.__name__:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (100 > 79 characters)
                      Open

                                  raise ModelError(f"Unsupported component: {type(components)} is not a valid component.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (93 > 79 characters)
                      Open

                          def __init__(self, name="", population=True, volume=1.0, tspan=None, annotation="model"):
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                              :returns: The reaction or list of reactions that were added to the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (100 > 79 characters)
                      Open

                                      name = assign.variable if isinstance(assign.variable, str) else assign.variable.name
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (86 > 79 characters)
                      Open

                                      len(self.listOfReactions), self._listOfSpecies, self._listOfParameters
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (116 > 79 characters)
                      Open

                              elif isinstance(components, FunctionDefinition) or type(components).__name__ == FunctionDefinition.__name__:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                              elif isinstance(species, Species) or type(species).__name__ == "Species":
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (95 > 79 characters)
                      Open

                                  errmsg = f"species must be of type Species or list of Species not {type(species)}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (105 > 79 characters)
                      Open

                                  errmsg = f"parameters must be of type Parameter or list of Parameter not {type(parameters)}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (99 > 79 characters)
                      Open

                                          f"Duplicate variable in rate_rules AND assignment_rules: {rate_rule.variable}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (117 > 79 characters)
                      Open

                                      f'Name "{name}" is unavailable. It is reserved for internal GillesPy use. Reserved Names: ({names}).'
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                                  raise ModelError(f'Name "{name}" is unavailable. A reaction with that name exists.')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (98 > 79 characters)
                      Open

                                  # If the rate parameter exists in the reaction, confirm that it is a part of the model
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (110 > 79 characters)
                      Open

                                  raise ModelError(f"Could not add/resolve reaction: {reaction.name}, Reason given: {err}") from err
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                              :param reactions: The reaction or list of reactions to be added to the model object
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                              :raises ModelError: If an invalid rate rule is provided or if rate rule validation fails.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (95 > 79 characters)
                      Open

                                  raise ModelError(f'Name "{name}" is unavailable. A species with that name exists.')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                              of accepted types other than lists and do not need to be in any particular order.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                              elif isinstance(components, Reaction) or type(components).__name__ == Reaction.__name__:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (95 > 79 characters)
                      Open

                              :raises ModelError: If an invalid parameter is provided or if Parameter.validate fails.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (95 > 79 characters)
                      Open

                              :returns: A dict of all parameters in the model, in the form: {name : parameter object}
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (98 > 79 characters)
                      Open

                              :returns: the dictionary mapping user parameter names to their internal GillesPy notation.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                                          from gillespy2.core import log # pylint:disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                                  raise ModelError(f'Name "{name}" is unavailable. A parameter with that name exists.')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                                  raise ModelError(f'Name "{name}" is unavailable. Names must not be numeric strings.')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (86 > 79 characters)
                      Open

                              :param species: The species or list of species to be added to the model object
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (86 > 79 characters)
                      Open

                                      errmsg = f"Could not add species: {species.name}, Reason given: {err}"
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (94 > 79 characters)
                      Open

                              :returns: A dict of all reactions in the model, in the form: {name : reaction object}.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (110 > 79 characters)
                      Open

                                      raise error_class('Invalid Rate/Assignment Rule. Expression must be a non-empty string value')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (116 > 79 characters)
                      Open

                                          errmsg = f"Changing {rate_rule.variable.name}.mode='continuous' as it is the target of RateRule"
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                      def import_SBML(filename, name=None, gillespy_model=None, report_silently_with_sbml_error=False):
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (83 > 79 characters)
                      Open

                          :param tspan: The timepoints at which the model should be simulated. If None, a
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                                  if event.trigger is None or not hasattr(event.trigger, 'expression'):
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (100 > 79 characters)
                      Open

                                      name = reaction.marate if isinstance(reaction.marate, str) else reaction.marate.name
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (108 > 79 characters)
                      Open

                              elif isinstance(components, AssignmentRule) or type(components).__name__ == AssignmentRule.__name__:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (82 > 79 characters)
                      Open

                              raise ModelError(f"{self.name} does not contain an element named {name}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                              :raises ModelError: If an invalid species is provided or if Species.validate fails.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (85 > 79 characters)
                      Open

                                  raise ModelError(f"{self.name} does not contain a species named {name}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                              :param parameters:  The parameter or list of parameters to be added to the model object.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (83 > 79 characters)
                      Open

                              :returns: The rate rule or list of rate rules that were added to the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (105 > 79 characters)
                      Open

                                      raise ModelError(f"Duplicate variable in assignments_rules: {assignment_rule.variable}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (104 > 79 characters)
                      Open

                              :type function_definition: gillespy2.FunctionDefinition | list of gillespy2.FunctionDefinitions.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (90 > 79 characters)
                      Open

                                      from gillespy2 import ODECSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                  from gillespy2 import TauHybridSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (83 > 79 characters)
                      Open

                                      f"argument 'solver={solver}' to run() failed.  Reason Given: {err}"
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                                  GillesPy2 may not support this feature.  Use Model._resolve_reaction instead.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (83 > 79 characters)
                      Open

                                  spec.append(sml_model.__species_to_element(model.listOfSpecies[sname]))
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (102 > 79 characters)
                      Open

                                  errmsg = f"rate_rule must be of type RateRule or list of RateRules not {type(rate_rule)}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (100 > 79 characters)
                      Open

                                  sanitized_assignment_rule = AssignmentRule(name=f'AR{len(self._listOfAssignmentRules)}')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (98 > 79 characters)
                      Open

                              Events, and Species with a dynamic, or continuous population must use the TauHybridSolver.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (86 > 79 characters)
                      Open

                              from gillespy2 import NumPySSASolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                  from gillespy2 import CLESolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (90 > 79 characters)
                      Open

                                  Model.problem_with_name has been deprecated.  Future releases of GillesPy2 may
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                                  Model.validate_reactants_and_products has been deprecated. Future releases of
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                                      raise InvalidStochMLError("No reaction type specified.") from err
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (80 > 79 characters)
                      Open

                                          "Unsupported or no reaction type given for reaction" + name)
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (93 > 79 characters)
                      Open

                              :type assignment_rules: gillespy2.AssignmentRule or list of gillespy2.AssignmentRules
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (95 > 79 characters)
                      Open

                              :returns: The assignment rule or list of assignment rules that were added to the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (109 > 79 characters)
                      Open

                              :raises ModelError: If an invalid assignment rule is provided or if assignment rule validation fails.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                                  ar_vars = [a_rule.variable for a_rule in self.listOfAssignmentRules.values()]
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (99 > 79 characters)
                      Open

                              :returns: A dict of all assignemt rules in the model, in the form: {name: reaction object}.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                                  raise ModelError(f"{self.name} does not contain a function definition named {name}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (118 > 79 characters)
                      Open

                              # A translation table is used to anonymize user-defined variable names and formulas into generic counterparts.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                              from gillespy2.solvers.cpp.build.build_engine import BuildEngine # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      At least two spaces before inline comment
                      Open

                                      from gillespy2 import ODECSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (85 > 79 characters)
                      Open

                                  from gillespy2 import ODESolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (95 > 79 characters)
                      Open

                                  if not isinstance(self.tspan, TimeSpan) or type(self.tspan).__name__ != "TimeSpan":
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                              from gillespy2.core import log # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (98 > 79 characters)
                      Open

                                  not support this feature.  Parameter.expression should only be set in the constructor.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Invalid escape sequence '\s'
                      Open

                                  text_re = re.compile(">\n\s+([^<>\s].*?)\n\s+</", re.DOTALL)
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Invalid escape sequences are deprecated in Python 3.6.

                      Okay: regex = r'\.png$'
W605: regex = '\.png$'

                      Line too long (113 > 79 characters)
                      Open

                                  dict(zip((str(x.name) for x in assignments), (f"AR_{x + 100}" for x in range(0, len(assignments))))),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (102 > 79 characters)
                      Open

                                  dict(zip((str(x.name) for x in events), (f"E_{x + 100}" for x in range(0, len(events))))),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (99 > 79 characters)
                      Open

                                  raise ModelError("units must be either concentration or population (case insensitive)")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (111 > 79 characters)
                      Open

                              Finds best solver for the users simulation. Currently, AssignmentRules, RateRules, FunctionDefinitions,
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (114 > 79 characters)
                      Open

                              from gillespy2.solvers.cpp.build.build_engine import BuildEngine # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                                      from gillespy2 import TauHybridCSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (82 > 79 characters)
                      Open

                              :param solver_args: Solver-specific arguments to be passed to solver.run()
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (88 > 79 characters)
                      Open

                              :param expression: String that may be executed in C, describing the value of the
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (101 > 79 characters)
                      Open

                                              f"Found a customized propensity function, but no expression was given. {err}"
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Invalid escape sequence '\s'
                      Open

                                  text_re = re.compile(">\n\s+([^<>\s].*?)\n\s+</", re.DOTALL)
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Invalid escape sequences are deprecated in Python 3.6.

                      Okay: regex = r'\.png$'
W605: regex = '\.png$'

                      Line too long (82 > 79 characters)
                      Open

                                  sanitized_rate_rule = RateRule(name=f'RR{len(self._listOfRateRules)}')
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (87 > 79 characters)
                      Open

                              :returns: A dict of all evetns in the model, in the form: {name : event object}
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (85 > 79 characters)
                      Open

                              :rtype: gillespy2.FunctionDefinitions | list of gillespy2.FunctionDefinitions
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (83 > 79 characters)
                      Open

                                      f"{self.name} does not contain a function definition named {name}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (87 > 79 characters)
                      Open

                                  during the simulation. Best to use the form gillespy2.TimeSpan(np.linspace(
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (88 > 79 characters)
                      Open

                              :param solver: The solver by which to simulate the model. This solver object may
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (114 > 79 characters)
                      Open

                              control+c or pressing stop on a jupyter notebook. To resume a simulation, pass your previously ran results
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                              from gillespy2.core import log # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (91 > 79 characters)
                      Open

                                  not support this feature.  This is an internal function and should not be used.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (115 > 79 characters)
                      Open

                              :returns: A dict of all function definitions in the model, in the form {name : function definition object}.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                              :param time_span: Evenly-spaced list of times at which to sample the species populations
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (110 > 79 characters)
                      Open

                                  dict(zip((str(x.name) for x in parameters), (f"P_{x + 100}" for x in range(0, len(parameters))))),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (101 > 79 characters)
                      Open

                                  dict(zip((str(x.name) for x in rates), (f"RR_{x + 100}" for x in range(0, len(rates))))),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                                  or Species with a dynamic or continuous population, it will choose SSACSolver
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                                  from gillespy2 import TauHybridSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (84 > 79 characters)
                      Open

                              windows_space = platform.system() == "Windows" and " " in gillespy2.__file__
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                      from gillespy2 import TauHybridCSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (80 > 79 characters)
                      Open

                              from gillespy2.core import log # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (84 > 79 characters)
                      Open

                              Ensure that the rate and all reactants and products are present in the model
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Invalid escape sequence '\s'
                      Open

                                  text_re = re.compile(">\n\s+([^<>\s].*?)\n\s+</", re.DOTALL)
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Invalid escape sequences are deprecated in Python 3.6.

                      Okay: regex = r'\.png$'
W605: regex = '\.png$'

                      Line too long (94 > 79 characters)
                      Open

                              :param rate_rule: The rate rule or list of rate rules to be added to the model object.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                                      if rate_rule.variable.mode is None or rate_rule.variable.mode == 'dynamic':
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (102 > 79 characters)
                      Open

                              :returns: The function defintion or list of function definitions that were added to the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (85 > 79 characters)
                      Open

                              if isinstance(time_span, TimeSpan) or type(time_span).__name__ == "TimeSpan":
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (104 > 79 characters)
                      Open

                                  dict(zip((str(x.name) for x in species), (f"S_{x + 100}" for x in range(0, len(species))))),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                                      from gillespy2 import TauLeapingCSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                  from gillespy2 import ODESolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (107 > 79 characters)
                      Open

                              :param algorithm: Specify algorithm ('ODE', 'Tau-Leaping', or 'SSA') for GillesPy2 to automatically
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (120 > 79 characters)
                      Open

                                      The integrator argument to run is only supported by the ODESolver.run method. To use the integrator use:
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                                              raise StochMLImportError(f"Reason given: {err}") from err
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (87 > 79 characters)
                      Open

                              elif isinstance(rate_rule, RateRule) or type(rate_rule).__name__ == "RateRule":
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                              :returns: A dict of all rate rules in the model, in the form: {name : rate rule object}.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (105 > 79 characters)
                      Open

                                          f"Duplicate variable in rate_rules AND assignment_rules: {assignment_rule.variable}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (90 > 79 characters)
                      Open

                                  self.listOfFunctionDefinitions[function_definition.name] = function_definition
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                      from gillespy2 import TauHybridCSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (90 > 79 characters)
                      Open

                                      from gillespy2 import SSACSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                                      from gillespy2 import TauHybridCSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (115 > 79 characters)
                      Open

                              :returns:  Returns a Results object that inherits UserList and contains one or more Trajectory objects that
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (116 > 79 characters)
                      Open

                              To pause a simulation and retrieve data before the simulation, keyboard interrupt the simulation by pressing
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Continuation line with same indent as next logical line
                      Open

                                          ("resume" in solver_args or "variables" in solver_args or "live_output" in solver_args):
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Continuation lines indentation.

                      Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                      Line too long (81 > 79 characters)
                      Open

                              :param event: The event or list of event to be added to the model object.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                              :raises ModelError: If an invalid event is provided or if event validation fails.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                                  errmsg = "function_definition must be of type FunctionDefinition or "
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Whitespace after '{'
                      Open

                                  dict({ self.name: "Model" }),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Avoid extraneous whitespace.

                      Avoid extraneous whitespace in these situations:
- Immediately inside parentheses, brackets or braces.
- Immediately before a comma, semicolon, or colon.

Okay: spam(ham[1], {eggs: 2})
E201: spam( ham[1], {eggs: 2})
E201: spam(ham[ 1], {eggs: 2})
E201: spam(ham[1], { eggs: 2})
E202: spam(ham[1], {eggs: 2} )
E202: spam(ham[1 ], {eggs: 2})
E202: spam(ham[1], {eggs: 2 })

E203: if x == 4: print x, y; x, y = y , x
E203: if x == 4: print x, y ; x, y = y, x
E203: if x == 4 : print x, y; x, y = y, x

                      Multiple spaces before keyword
                      Open

                              if len(self.get_all_rate_rules())  or len(self.get_all_events()):
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Avoid extraneous whitespace around keywords.

                      Okay: True and False
E271: True and  False
E272: True  and False
E273: True and\tFalse
E274: True\tand False

                      Line too long (92 > 79 characters)
                      Open

                              if len(self.get_all_assignment_rules()) or len(self.get_all_function_definitions()):
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (114 > 79 characters)
                      Open

                              If user has specified a particular algorithm, we return either the Python or C++ version of that algorithm
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (93 > 79 characters)
                      Open

                                               "Please enter 'SSA', 'ODE', 'CLE', 'Tau-Leaping', or 'Tau-Hybrid'.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (99 > 79 characters)
                      Open

                              :returns: Set containing the classes of every solver-specific feature present on the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (97 > 79 characters)
                      Open

                          def run(self, solver=None, timeout=0, t=None, increment=None, algorithm=None, **solver_args):
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (120 > 79 characters)
                      Open

                              into the run method, and set t = to the time you wish the resuming simulation to end (run(resume=results, t=x)).
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                              from gillespy2.core import log # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (83 > 79 characters)
                      Open

                                  rr_vars = [r_rule.variable for r_rule in self.listOfRateRules.values()]
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                                  self._listOfAssignmentRules[assignment_rule.name] = sanitized_assignment_rule
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Continuation line over-indented for visual indent
                      Open

                                              type(function_definition).__name__ == "FunctionDefinition":
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Continuation lines indentation.

                      Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                      Line too long (85 > 79 characters)
                      Open

                                  errmsg += f"list of FunctionDefinitions not {type(function_definition)}."
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (118 > 79 characters)
                      Open

                              :param precompile: If True, and the model contains no AssignmentRules, RateRules, FunctionDefinitions, Events,
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (86 > 79 characters)
                      Open

                                  from gillespy2 import SSACSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (110 > 79 characters)
                      Open

                              chybrid_check = not (len(self.get_all_assignment_rules()) or len(self.get_all_function_definitions()))
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                      from gillespy2 import SSACSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      At least two spaces before inline comment
                      Open

                                  from gillespy2 import NumPySSASolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (90 > 79 characters)
                      Open

                              :param timeout: Allows a time_out value in seconds to be sent to a signal handler,
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (88 > 79 characters)
                      Open

                              for the given reaction.  This methods must be called before exporting the model.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (84 > 79 characters)
                      Open

                              Set the value of an existing parameter "pname" to "expression" (deprecated).
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (108 > 79 characters)
                      Open

                                  dict(zip((str(x.name) for x in reactions), (f"R_{x + 100}" for x in range(0, len(reactions))))),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (108 > 79 characters)
                      Open

                                  dict(zip((str(x.name) for x in functions), (f"F_{x + 100}" for x in range(0, len(functions))))),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                  from gillespy2 import SSACSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (92 > 79 characters)
                      Open

                                  from gillespy2 import TauLeapingSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (108 > 79 characters)
                      Open

                                          ("resume" in solver_args or "variables" in solver_args or "live_output" in solver_args):
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (80 > 79 characters)
                      Open

                              from gillespy2.core import log # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (80 > 79 characters)
                      Open

                              from gillespy2.core import log # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Continuation line under-indented for visual indent
                      Open

                                                            expression=ratename)
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Continuation lines indentation.

                      Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                      Line too long (87 > 79 characters)
                      Open

                                  raise ModelError(f"{self.name} does not contain a rate rule named {name}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (84 > 79 characters)
                      Open

                                  raise ModelError(f"{self.name} does not contain an event named {name}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (83 > 79 characters)
                      Open

                                              type(function_definition).__name__ == "FunctionDefinition":
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                              from gillespy2.solvers.cpp.build.build_engine import BuildEngine # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      At least two spaces before inline comment
                      Open

                                  from gillespy2 import TauLeapingSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (85 > 79 characters)
                      Open

                                  from gillespy2 import CLESolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (87 > 79 characters)
                      Open

                                  return solver.run(t=t, increment=increment, timeout=timeout, **solver_args)
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Expected 2 blank lines, found 1
                      Open

                      class StochMLDocument():
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate top-level function and class definitions with two blank lines.

                      Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                      Line too long (92 > 79 characters)
                      Open

                                      raise ModelError(f"Duplicate variable in rate_rules: {rate_rule.variable}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (82 > 79 characters)
                      Open

                                  sanitized_assignment_rule.formula = assignment_rule.sanitized_formula(
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                      from gillespy2 import TauLeapingCSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (90 > 79 characters)
                      Open

                                  from gillespy2 import NumPySSASolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (91 > 79 characters)
                      Open

                                  from gillespy2 import TauHybridSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (96 > 79 characters)
                      Open

                                  be initialized separately to specify an algorithm. Optional, defaults to ssa solver.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (81 > 79 characters)
                      Open

                                              raise StochMLImportError(f"Reason given: {err}") from err
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (89 > 79 characters)
                      Open

                                  ar_vars = [a_rule.variable for a_rule in self.listOfAssignmentRules.values()]
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (111 > 79 characters)
                      Open

                              elif isinstance(assignment_rule, AssignmentRule) or type(assignment_rule).__name__ == "AssignmentRule":
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (94 > 79 characters)
                      Open

                              :param function_definition: The function definition, or list of function definitions \
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      At least two spaces before inline comment
                      Open

                                  from gillespy2 import TauHybridSolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (104 > 79 characters)
                      Open

                                      raise SimulationError(f"{solver} is not a valid solver.  Reason Given: {err}.") from err
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (101 > 79 characters)
                      Open

                                  reacs.append(sml_model.__reaction_to_element(model.listOfReactions[rname], model.volume))
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (113 > 79 characters)
                      Open

                              :param assignment_rules: The assignment rule or list of assignment rules to be added to the model object.
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (94 > 79 characters)
                      Open

                                  raise ModelError(f"{self.name} does not contain an assignment rule named {name}.")
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (87 > 79 characters)
                      Open

                                  errmsg = f"event must be of type Event or list of Events not {type(event)}"
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Whitespace before '}'
                      Open

                                  dict({ self.name: "Model" }),
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Avoid extraneous whitespace.

                      Avoid extraneous whitespace in these situations:
- Immediately inside parentheses, brackets or braces.
- Immediately before a comma, semicolon, or colon.

Okay: spam(ham[1], {eggs: 2})
E201: spam( ham[1], {eggs: 2})
E201: spam(ham[ 1], {eggs: 2})
E201: spam(ham[1], { eggs: 2})
E202: spam(ham[1], {eggs: 2} )
E202: spam(ham[1 ], {eggs: 2})
E202: spam(ham[1], {eggs: 2 })

E203: if x == 4: print x, y; x, y = y , x
E203: if x == 4: print x, y ; x, y = y, x
E203: if x == 4 : print x, y; x, y = y, x

                      At least two spaces before inline comment
                      Open

                              from gillespy2 import NumPySSASolver # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Separate inline comments by at least two spaces.

                      An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                      Line too long (114 > 79 characters)
                      Open

                              from gillespy2.solvers.cpp.build.build_engine import BuildEngine # pylint: disable=import-outside-toplevel
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (86 > 79 characters)
                      Open

                                  Model.set_parameter has been deprecated.  Future releases of GillesPy2 may
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Line too long (84 > 79 characters)
                      Open

                                              kwargs['rate'] = model.listOfParameters[generated_rate_name]
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Limit all lines to a maximum of 79 characters.

                      There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                      Invalid escape sequence '\g'
                      Open

                                  pretty_xml = text_re.sub(">\g<1></", ugly_xml)
                      Severity: Minor
                      Found in gillespy2/core/model.py by pep8

                      Invalid escape sequences are deprecated in Python 3.6.

                      Okay: regex = r'\.png$'
W605: regex = '\.png$'

                      There are no issues that match your filters.

                      Category
                      Status