KarrLab/wc_model_gen

View on GitHub

Showing 120 of 341 total issues

Function gen_reactions has a Cognitive Complexity of 222 (exceeds 5 allowed). Consider refactoring.
Open

    def gen_reactions(self):
        """ Generate reactions associated with submodel """
        model = self.model
        cell = self.knowledge_base.cell

Severity: Minor
Found in wc_model_gen/eukaryote/complexation.py - About 4 days 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 gen_reactions has a Cognitive Complexity of 192 (exceeds 5 allowed). Consider refactoring.
Open

    def gen_reactions(self):
        """ Generate reactions associated with submodel 
        
        Exchange reactions for components in the media will be be created if they do 
        not exist. The maximum and minimum flux bounds for exchange reactions will also be set.
Severity: Minor
Found in wc_model_gen/eukaryote/metabolism.py - About 3 days 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

File translation_translocation.py has 1320 lines of code (exceeds 250 allowed). Consider refactoring.
Open

""" Generator for translation, protein folding and translocation submodel for eukaryotes
:Author: Yin Hoon Chew <yinhoon.chew@mssm.edu>
:Date: 2019-06-14
:Copyright: 2019, Karr Lab
:License: MIT
Severity: Major
Found in wc_model_gen/eukaryote/translation_translocation.py - About 3 days to fix

    Function gen_rate_laws has a Cognitive Complexity of 164 (exceeds 5 allowed). Consider refactoring.
    Open

        def gen_rate_laws(self):
            """ Generate rate laws for the reactions in the submodel """
            model = self.model
            cell = self.knowledge_base.cell
    
    
    Severity: Minor
    Found in wc_model_gen/eukaryote/translation_translocation.py - About 3 days 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 calibrate_submodel has a Cognitive Complexity of 142 (exceeds 5 allowed). Consider refactoring.
    Open

        def calibrate_submodel(self):
            """ Calibrate the submodel using data in the KB """
            
            model = self.model        
            cell = self.knowledge_base.cell
    Severity: Minor
    Found in wc_model_gen/eukaryote/translation_translocation.py - About 2 days 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

    File transcription.py has 1089 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    """ Generator for transcription submodels for eukaryotes
    
    :Author: Yin Hoon Chew <yinhoon.chew@mssm.edu>
    :Date: 2019-01-07
    :Copyright: 2019, Karr Lab
    Severity: Major
    Found in wc_model_gen/eukaryote/transcription.py - About 2 days to fix

      Function impute_kinetic_constant has a Cognitive Complexity of 118 (exceeds 5 allowed). Consider refactoring.
      Open

          def impute_kinetic_constant(self, bound_values):
              """ Impute the values of kcat that have not been measured.
      
              Args:
                  bound_values (:obj:`dict`): Keys are reaction IDs and values are tuples 
      Severity: Minor
      Found in wc_model_gen/eukaryote/metabolism.py - About 2 days 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

      File metabolism.py has 921 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      """ Generator for metabolism submodel for eukaryotes
      
      :Author: Yin Hoon Chew <yinhoon.chew@mssm.edu>
      :Date: 2020-01-21
      :Copyright: 2020, Karr Lab
      Severity: Major
      Found in wc_model_gen/eukaryote/metabolism.py - About 2 days to fix

        Function gen_species_type has a Cognitive Complexity of 108 (exceeds 5 allowed). Consider refactoring.
        Open

            def gen_species_type(self, kb_species_type, extra_compartment_ids=None):
                """ Generate a model species type and species
        
                Args:
                    kb_species_type (:obj:`wc_kb.SpeciesType`): knowledge base species type
        Severity: Minor
        Found in wc_model_gen/eukaryote/initialize_model.py - About 2 days 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

        File initialize_model.py has 861 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        """ Initialize the construction of wc_lang-encoded models from wc_kb-encoded knowledge base.
        
        :Author: Yin Hoon Chew <yinhoon.chew@mssm.edu>
        :Date: 2019-01-09
        :Copyright: 2019, Karr Lab
        Severity: Major
        Found in wc_model_gen/eukaryote/initialize_model.py - About 2 days to fix

          Function gen_reactions has a Cognitive Complexity of 74 (exceeds 5 allowed). Consider refactoring.
          Open

              def gen_reactions(self):
                  """ Generate reactions associated with submodel """
                  model = self.model
                  cell = self.knowledge_base.cell
                  
          Severity: Minor
          Found in wc_model_gen/eukaryote/translation_translocation.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

          Function gen_reactions has a Cognitive Complexity of 65 (exceeds 5 allowed). Consider refactoring.
          Open

              def gen_reactions(self):
                  """ Generate reactions associated with submodel """
                  model = self.model
                  cell = self.knowledge_base.cell
                  nucleus = model.compartments.get_one(id='n')
          Severity: Minor
          Found in wc_model_gen/eukaryote/transcription.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

          Function calibrate_submodel has a Cognitive Complexity of 63 (exceeds 5 allowed). Consider refactoring.
          Open

              def calibrate_submodel(self):
                  """ Calibrate the submodel using data in the KB """
                  
                  model = self.model        
                  cell = self.knowledge_base.cell
          Severity: Minor
          Found in wc_model_gen/eukaryote/transcription.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

          File utils.py has 567 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          """ Utility methods for generating submodels
          
          :Author: Yin Hoon Chew <yinhoon.chew@mssm.edu>
          :Date: 2019-01-23
          :Copyright: 2019, Karr Lab
          Severity: Major
          Found in wc_model_gen/utils.py - About 1 day to fix

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

                def gen_rate_laws(self):
                    """ Generate rate laws for the reactions in the submodel """
            
                    model = self.model        
                    cell = self.knowledge_base.cell
            Severity: Minor
            Found in wc_model_gen/eukaryote/transcription.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

            Function determine_bounds has a Cognitive Complexity of 46 (exceeds 5 allowed). Consider refactoring.
            Open

                def determine_bounds(self):
                    """ Determine the minimum and maximum bounds for each reaction. The bounds will be
                        scaled according to the provided scale factor.
            
                    Returns:
            Severity: Minor
            Found in wc_model_gen/eukaryote/metabolism.py - About 7 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 test_metabolite_production has a Cognitive Complexity of 45 (exceeds 5 allowed). Consider refactoring.
            Open

            def test_metabolite_production(submodel, reaction_bounds, pseudo_reactions=None, 
                test_producibles=None, test_recyclables=None):
                """ Test that an FBA metabolism submodel can produce each reactant component (producible) 
                    and recycle each product component (recyclable) in each reaction in the objective 
                    function individually. First, a source (sink) reaction is added for each reactant 
            Severity: Minor
            Found in wc_model_gen/utils.py - About 6 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 determine_initial_concentration has a Cognitive Complexity of 45 (exceeds 5 allowed). Consider refactoring.
            Open

                def determine_initial_concentration(self):
                    """ Estimate the initial concentrations of complex species using the following steps: 
            
                        1) For each complex species, calculate the maximum possible copy number by taking the minimum
                           of the availability of each subunit, which is determined as the ratio of
            Severity: Minor
            Found in wc_model_gen/eukaryote/complexation.py - About 6 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 gen_reactions has a Cognitive Complexity of 44 (exceeds 5 allowed). Consider refactoring.
            Open

                def gen_reactions(self):
                    """ Generate reactions associated with submodel """
                    model = self.model
                    cell = self.knowledge_base.cell
            
            
            Severity: Minor
            Found in wc_model_gen/eukaryote/protein_degradation.py - About 6 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 gen_rate_laws has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.
            Open

                def gen_rate_laws(self):
                    """ Generate rate laws for the reactions in the submodel """
                    model = self.model
                    compartment_proteasomes = self.options['compartment_proteasomes']
                    
            Severity: Minor
            Found in wc_model_gen/eukaryote/protein_degradation.py - About 6 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

            Severity
            Category
            Status
            Source
            Language