Sign upLogin

KissPeter/APIFuzzer

View on GitHub
Star
apifuzzer/openapi_template_generator.py

Summary

Maintainability
D
1 day
Test Coverage
B
82%

Function _process_api_resources has a Cognitive Complexity of 43 (exceeds 5 allowed). Consider refactoring.
Open

    def _process_api_resources(self, paths=None, existing_template=None):
        if paths is None:
            paths = self.api_resources.get("paths")
        for resource in paths.keys():
            normalized_url = self._normalize_url(resource)
Severity: Minor
Found in apifuzzer/openapi_template_generator.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

File openapi_template_generator.py has 323 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import json
from urllib.parse import urlparse

from json_ref_dict import materialize, RefDict
Severity: Minor
Found in apifuzzer/openapi_template_generator.py - About 3 hrs to fix

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

        def _process_api_resources(self, paths=None, existing_template=None):
        if paths is None:
            paths = self.api_resources.get("paths")
        for resource in paths.keys():
            normalized_url = self._normalize_url(resource)
    Severity: Minor
    Found in apifuzzer/openapi_template_generator.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 _process_request_body has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
    Open

        def _process_request_body(self):
        paths = self.api_resources["paths"]
        request_body_paths = dict()
        for resource in paths.keys():
            normalized_url = self._normalize_url(resource)
    Severity: Minor
    Found in apifuzzer/openapi_template_generator.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 _process_request_body. (8)
    Open

        def _process_request_body(self):
        paths = self.api_resources["paths"]
        request_body_paths = dict()
        for resource in paths.keys():
            normalized_url = self._normalize_url(resource)
    Severity: Minor
    Found in apifuzzer/openapi_template_generator.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_field_to_param. (8)
    Open

        def _add_field_to_param(self, fuzz_type, param, param_name, parameter_place_in_request, sample_data, template):
        if parameter_place_in_request == ParamTypes.PATH:
            template.path_variables.add(
                fuzz_type(name=param_name, value=str(sample_data))
            )
    Severity: Minor
    Found in apifuzzer/openapi_template_generator.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_field_to_param has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
    Open

        def _add_field_to_param(self, fuzz_type, param, param_name, parameter_place_in_request, sample_data, template):
        if parameter_place_in_request == ParamTypes.PATH:
            template.path_variables.add(
                fuzz_type(name=param_name, value=str(sample_data))
            )
    Severity: Minor
    Found in apifuzzer/openapi_template_generator.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_field_to_param has 7 arguments (exceeds 4 allowed). Consider refactoring.
    Open

        def _add_field_to_param(self, fuzz_type, param, param_name, parameter_place_in_request, sample_data, template):
    Severity: Major
    Found in apifuzzer/openapi_template_generator.py - About 50 mins to fix

      Refactor this function to reduce its Cognitive Complexity from 19 to the 15 allowed.
      Open

          def _process_request_body(self):
      Severity: Critical
      Found in apifuzzer/openapi_template_generator.py by sonar-python

      Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

      See

      Refactor this function to reduce its Cognitive Complexity from 44 to the 15 allowed.
      Open

          def _process_api_resources(self, paths=None, existing_template=None):
      Severity: Critical
      Found in apifuzzer/openapi_template_generator.py by sonar-python

      Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

      See

      Either merge this branch with the identical one on line "257" or change one of the implementations.
      Open

                  template.params.add(
                fuzz_type(name=param_name, value=str(sample_data))
            )
      Severity: Major
      Found in apifuzzer/openapi_template_generator.py by sonar-python

      Having two branches in the same if structure with the same implementation is at best duplicate code, and at worst a coding error. If the same logic is truly needed for both instances, then they should be combined.

      Noncompliant Code Example

      if 0 <= a < 10:
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
elif 20 <= a < 50:
    do_the_thing()  # Noncompliant; duplicates first condition
else:
    do_the_rest()

b = 4 if a > 12 else 4

      Compliant Solution

      if (0 <= a < 10) or (20 <= a < 50):
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
else:
    do_the_rest()

b = 4

      or 

      if 0 <= a < 10:
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
elif 20 <= a < 50:
    do_the_third_thing()
else:
    do_the_rest()

b = 8 if a > 12 else 4

      Line too long (82 > 79 characters)
      Open

                          template.content_type = paths[resource][method]["consumes"][0]
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                          # as multiple content types can exist here, we need to open up new template
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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"Resource: {resource} Method: {method}, CT: {content_type}"
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                          for k, v in paths[resource][method]["requestBody"]["content"][
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                      self.logger.info("Resource: {} Method: {}".format(resource, method))
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                      for param in list(paths[resource][method].get("parameters", {})):
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                              sample_data = _get_sample_data_by_type(param.get("type"))
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

              Kitty doesn't support some characters as template name so need to be cleaned, but it is necessary,
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                          if not request_body_paths[resource][method].get("parameters"):
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 unaligned for hanging indent
      Open

                                      .get(_param)
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 (80 > 79 characters)
      Open

                      self.logger.debug(f"Loading existing template: {template.name}")
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                  f"Adding template to list: {template.name}, templates list: {len(self.templates)}"
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

          This class processes the Swagger, OpenAPI v2 and OpenAPI v3 definitions. Generates Fuzz template from the params
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 apifuzzer.fuzz_utils import _get_sample_data_by_type, get_fuzz_type_by_param_type
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                          paths[resource][method].get("requestBody", {}).get("content", [])
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 (107 > 79 characters)
      Open

              Starts new template if it does not exist yet or retrun the existing one which has the required name
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                          template_name = f"{normalized_url}|{method}-{self._split_content_type(content_type)}"
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                              request_body_paths[resource][method]["parameters"].append(
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                  _base_url = "/".join([alternate_url.strip("/"), uri.path.strip("/")])
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                              fuzzer_type = self._get_fuzzer_type(_parameter, param_format, parameter_data_type)
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                              sample_data = self._get_sample_data(_parameter, fuzz_type, sample_data)
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 unaligned for hanging indent
      Open

                      .get(_param)
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 (93 > 79 characters)
      Open

                                  f"Adding property: {param_name} with type: {parameter_data_type}"
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                      "Failed to find base url, using the alternative one ({})".format(
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                              parameters.append(self._get_additional_parameters(_param, param, param_name,
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 (107 > 79 characters)
      Open

                                  f" Parameter place: {parameter_place_in_request} \n Sample data: {sample_data}"
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                                  f"Resource: {resource} Method: {method} \n Parameter: {param} \n"
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                                  f"\n Param name: {param_name}\n fuzzer_type: {fuzzer_type} "
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

          def _get_additional_parameters(_param, param, param_name, parameter_data_type):
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

          def _add_field_to_param(self, fuzz_type, param, param_name, parameter_place_in_request, sample_data, template):
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 (119 > 79 characters)
      Open

                              self._add_field_to_param(fuzz_type, param, param_name, parameter_place_in_request, sample_data,
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

              :param alternate_url: alternate protocol and base url to be used instead of the one defined in swagger
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                                                                                parameter_data_type))
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                      _protocol, self.api_resources["host"], self.api_resources["basePath"]
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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

                  uri = urlparse(self.api_resources.get("servers", [{}])[0].get("url"))
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.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 an indentation at 48 instead of at 49.
      Open

                                                       template)
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.py by editorconfig

      Expected an indentation at 76 instead of at 74.
      Open

                                                                                parameter_data_type))
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.py by editorconfig

      Expected an indentation at 8 instead of at 9.
      Open

               application/json                 -> json
      Severity: Minor
      Found in apifuzzer/openapi_template_generator.py by editorconfig

      There are no issues that match your filters.

      Category
      Status