Showing 22 of 111 total issues
File provisioner.py
has 478 lines of code (exceeds 250 allowed). Consider refactoring. Open
from bluebees.common.client import Client
from dataclasses import dataclass
from bluebees.common.utils import order, crc8
from asyncio import wait_for
from ecdsa import NIST256p, SigningKey
File config.py
has 430 lines of code (exceeds 250 allowed). Consider refactoring. Open
from bluebees.client.node.node_data import node_name_list
from bluebees.client.application.application_data import ApplicationData, app_name_list
from bluebees.client.node.node_data import NodeData
from bluebees.client.network.network_data import NetworkData
from bluebees.common.file import file_helper
File transport_layer.py
has 357 lines of code (exceeds 250 allowed). Consider refactoring. Open
from bluebees.client.mesh_layers.network_layer import NetworkLayer
from bluebees.client.mesh_layers.mesh_context import SoftContext
from bluebees.client.network.network_data import NetworkData
from bluebees.client.application.application_data import ApplicationData
from bluebees.client.node.node_data import NodeData
Function _change_random
has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring. Open
def _change_random(self, field_value: str):
while True:
if re.findall(r'\\d', field_value):
val = str(randint(0, 9))
field_value = field_value.replace('\\d', val, 1)
- 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 __init__
has 9 arguments (exceeds 4 allowed). Consider refactoring. Open
def __init__(self, loop, device_uuid: bytes, netkey: bytes,
Function _obsfucate
has 9 arguments (exceeds 4 allowed). Consider refactoring. Open
def _obsfucate(self, ctl: int, ttl: int, seq: int, src: bytes,
Function __check_addresses
has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring. Open
def __check_addresses(self, recv_ctx: SoftContext,
ctx: SoftContext) -> bool:
if address_type(recv_ctx.dst_addr) == UNICAST_ADDRESS:
send_dst_type = address_type(ctx.dst_addr)
if send_dst_type == UNICAST_ADDRESS:
- 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 find_key
has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring. Open
def find_key(obj_dict: dict, key: str):
for k in obj_dict.keys():
if k == key:
return obj_dict[k]
elif type(obj_dict[k]) != dict:
- 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 __init__
has 7 arguments (exceeds 4 allowed). Consider refactoring. Open
def __init__(self, name, addr, network, device_uuid, devkey, seq=0, apps=[]):
Function __init__
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
def __init__(self, name, key, key_index, iv_index, apps=[], nodes=[]):
Function req
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
def req(target, opcode, parameters, r_opcode, devkey, app):
Function run
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
def run(baudrate, port, search_dongle):
'''Run the main features of bluebees. This features are:
- Dongle Communication
- Internal Broker'''
- 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 new
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
def new(name, network, address, uuid, template):
Function aes_ccm_complete
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
def aes_ccm_complete(self, key: bytes, nonce: bytes, text: bytes, adata: bytes, mic_size=8):
Function send
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
def send(target, opcode, parameters, devkey, app):
Function provisioning_device
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
def provisioning_device(device_uuid: bytes, network: str,
Function __init__
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
def __init__(self, name, key, key_index, network, nodes=[]):
Function check_opcode
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
def check_opcode(opcode: bytes):
if len(opcode) > 3:
raise OpcodeLengthError
opcode_int = opcode[0]
- 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 update_sequence
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
def update_sequence(self, template, field_name, custom_pattern=None):
field_raw_value = template[field_name]
if type(field_raw_value) != str:
return None
- 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 validate_addr
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
def validate_addr(ctx, param, value):
if not value:
raise click.BadParameter('The maximum number of nodes was '
'reached')
if not check_hex_string(value):
- 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"