Showing 191 of 191 total issues
Function get_auto_start_list
has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring. Open
def get_auto_start_list(cpc):
"""
Helper functoin that converts the 'auto-start-list' property of a CPC
to a list suitable for the zhmcclient.Cpc.set_auto_start_list() method.
- Read upRead up
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 click_exception
has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring. Open
def click_exception(exc, error_format):
"""
Return a ClickException object with the message from an input exception
in a desired error message format.
- Read upRead up
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 lpar_scsi_load
has 7 arguments (exceeds 4 allowed). Consider refactoring. Open
def lpar_scsi_load(cmd_ctx, cpc, lpar, load_address, wwpn, lun, **options):
Function cmd_lpar_scsi_dump
has 7 arguments (exceeds 4 allowed). Consider refactoring. Open
def cmd_lpar_scsi_dump(cmd_ctx, cpc_name, lpar_name, load_address,
Function lpar_scsi_dump
has 7 arguments (exceeds 4 allowed). Consider refactoring. Open
def lpar_scsi_dump(cmd_ctx, cpc, lpar, load_address, wwpn, lun, **options):
Function cmd_lpar_scsi_load
has 7 arguments (exceeds 4 allowed). Consider refactoring. Open
def cmd_lpar_scsi_load(cmd_ctx, cpc_name, lpar_name, load_address,
Function print_dicts_as_table
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
def print_dicts_as_table(
Function dict_as_table
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
def dict_as_table(data, headers, table_format, show_list=None):
"""
Return a string with the dictionary data in tabular output format.
The order of rows is ascending by dictionary key.
- Read upRead up
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 print_resources
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
def print_resources(
Function print_resources_as_table
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
def print_resources_as_table(
Function cmd_partition_zeroize_crypto
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
def cmd_partition_zeroize_crypto(
cmd_ctx, cpc_name, partition_name, options):
# pylint: disable=missing-function-docstring
client = zhmcclient.Client(cmd_ctx.session)
- Read upRead up
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 print_object_values
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
def print_object_values(
Avoid deeply nested control flow statements. Open
if not filter_lpar:
included = True
elif ov.resource_uri == filter_lpar.uri:
included = True
elif resource_class == 'adapter':
Avoid deeply nested control flow statements. Open
if not filter_partition:
included = True
elif ov.resource.manager.partition.uri == \
filter_partition.uri:
if not filter_nic:
Function set_vlan_id_type
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
def set_vlan_id_type(cmd_ctx, properties, org_options):
"""
Set the 'vlan-id' and 'vlan-type' properties from the options.
"""
vlan_id = org_options['vlan-id']
- Read upRead up
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 cmd_cpc_update
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
def cmd_cpc_update(cmd_ctx, cpc_name, options):
# pylint: disable=missing-function-docstring
client = zhmcclient.Client(cmd_ctx.session)
cpc = find_cpc(cmd_ctx, client, cpc_name)
- Read upRead up
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 print_dicts
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
def print_dicts(
Avoid deeply nested control flow statements. Open
if not filter_partition:
included = True
elif ov.resource_uri == filter_partition.uri:
included = True
elif resource_class == 'logical-partition':
Function cmd_vfunction_update
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
def cmd_vfunction_update(cmd_ctx, cpc_name, partition_name, vfunction_name,
options):
# pylint: disable=missing-function-docstring
client = zhmcclient.Client(cmd_ctx.session)
- Read upRead up
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 cmd_ldapdef_create
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
def cmd_ldapdef_create(cmd_ctx, options):
# pylint: disable=missing-function-docstring
client = zhmcclient.Client(cmd_ctx.session)
console = client.consoles.console
- Read upRead up
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"