django/django

View on GitHub

Showing 2,094 of 2,094 total issues

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

    def as_widget(self, widget=None, attrs=None, only_initial=False):
        """
        Render the field by rendering the passed widget, adding any HTML
        attributes passed as attrs. If a widget isn't specified, use the
        field's default widget.
Severity: Minor
Found in django/forms/boundfield.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 send_mail has 6 arguments (exceeds 4 allowed). Consider refactoring.
Open

    def send_mail(
Severity: Minor
Found in django/contrib/auth/forms.py - About 45 mins to fix

    Function message_user has 6 arguments (exceeds 4 allowed). Consider refactoring.
    Open

        def message_user(
    Severity: Minor
    Found in django/contrib/admin/options.py - About 45 mins to fix

      Avoid deeply nested control flow statements.
      Open

                              for field in unique_check:
                                  if field in form.cleaned_data:
                                      del form.cleaned_data[field]
                          # mark the data as seen
                          seen_data.add(row_data)
      Severity: Major
      Found in django/forms/models.py - About 45 mins to fix

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

        def get_default_username(check_db=True, database=DEFAULT_DB_ALIAS):
            """
            Try to determine the current system user's username to use as a default.
        
            :param check_db: If ``True``, requires that the username does not match an
        Severity: Minor
        Found in django/contrib/auth/management/__init__.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 _check_values has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
        Open

            def _check_values(self, value):
                """
                Given a list of possible PK values, return a QuerySet of the
                corresponding objects. Raise a ValidationError if a given value is
                invalid (not a valid PK, not in the queryset, etc.)
        Severity: Minor
        Found in django/forms/models.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

        Avoid deeply nested control flow statements.
        Open

                                    if not input_value.strip():
                                        user_data[field_name] = None
                                        self.stderr.write("Error: This field cannot be blank.")
                                        continue
                                    user_data[field_name] = [
        Severity: Major
        Found in django/contrib/auth/management/commands/createsuperuser.py - About 45 mins to fix

          Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
          Open

              def __init__(self, field, request, params, model, model_admin, field_path):
          Severity: Minor
          Found in django/contrib/admin/filters.py - About 45 mins to fix

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

                def get_formset(self, request, obj=None, **kwargs):
                    if "fields" in kwargs:
                        fields = kwargs.pop("fields")
                    else:
                        fields = flatten_fieldsets(self.get_fieldsets(request, obj))
            Severity: Minor
            Found in django/contrib/contenttypes/admin.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 __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                def __init__(self, field, request, params, model, model_admin, field_path):
            Severity: Minor
            Found in django/contrib/admin/filters.py - About 45 mins to fix

              Function create_contenttypes has 6 arguments (exceeds 4 allowed). Consider refactoring.
              Open

              def create_contenttypes(
              Severity: Minor
              Found in django/contrib/contenttypes/management/__init__.py - About 45 mins to fix

                Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                    def __init__(self, field, request, params, model, model_admin, field_path):
                Severity: Minor
                Found in django/contrib/admin/filters.py - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                          if attr is sentinel:
                                              return None, None, None
                                  value = attr
                  Severity: Major
                  Found in django/contrib/admin/utils.py - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                        if site is not None:
                                            object_domain = site.domain
                                            break
                    
                        # If all that malarkey found an object domain, use it. Otherwise, fall back
                    Severity: Major
                    Found in django/contrib/contenttypes/views.py - About 45 mins to fix

                      Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                          def __init__(
                      Severity: Minor
                      Found in django/contrib/postgres/forms/array.py - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                                if form.has_changed():
                                                    obj = self.save_form(request, form, change=True)
                                                    self.save_model(request, obj, form, change=True)
                                                    self.save_related(request, form, formsets=[], change=True)
                                                    change_msg = self.construct_change_message(
                        Severity: Major
                        Found in django/contrib/admin/options.py - About 45 mins to fix

                          Function log_actions has 6 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                              def log_actions(
                          Severity: Minor
                          Found in django/contrib/admin/models.py - About 45 mins to fix

                            Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
                            Open

                                def __init__(self, field, request, params, model, model_admin, field_path):
                            Severity: Minor
                            Found in django/contrib/admin/filters.py - About 45 mins to fix

                              Function log_action has 6 arguments (exceeds 4 allowed). Consider refactoring.
                              Open

                                  def log_action(
                              Severity: Minor
                              Found in django/contrib/admin/models.py - About 45 mins to fix

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

                                    def get_context(self, name, value, attrs=None):
                                        attrs = {} if attrs is None else attrs
                                        context = super().get_context(name, value, attrs)
                                        if self.is_localized:
                                            self.widget.is_localized = self.is_localized
                                Severity: Minor
                                Found in django/contrib/postgres/forms/array.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

                                Severity
                                Category
                                Status
                                Source
                                Language