detect_platform
has a cyclomatic complexity of 16 with "high" risk 74def detect_python():
75 return pyplatform.python_version()
76
77def detect_platform(): 78 base_mapping = {
79 'gentoo base system': 'gentoo',
80 'centos linux': 'centos',
HttpContext.file
has a cyclomatic complexity of 19 with "high" risk345
346 return compressed
347
348 def file(self, path, stream=False, inline=False, name=None):349 """
350 Returns a GZip compressed response with content of file located in ``path`` and correct headers
351
ResourcesHandler.handle_build
has a cyclomatic complexity of 20 with "high" risk 40
41 @get(r'/resources/all\.(?P<group>.+)')
42 @endpoint(page=True, auth=False)
43 def handle_build(self, http_context, group=None): 44 """
45 Deliver all extern resources for the current page.
46
PluginManager.load_all_from
has a cyclomatic complexity of 31 with "very-high" risk258 if self[plugin]['imported']:
259 yield self[plugin]['info']['name']
260
261 def load_all_from(self, providers):262 """
263 Loads all plugins provided by given providers.
264
GateMiddleware.handle
has a cyclomatic complexity of 21 with "high" risk162 if not session.is_dead():
163 session.gate.send_sessionlist()
164
165 def handle(self, http_context):166 start_time = time.time()
167
168 self.vacuum()
A function with high cyclomatic complexity can be hard to understand and maintain. Cyclomatic complexity is a software metric that measures the number of independent paths through a function. A higher cyclomatic complexity indicates that the function has more decision points and is more complex.
Functions with high cyclomatic complexity are more likely to have bugs and be harder to test. They may lead to reduced code maintainability and increased development time.
To reduce the cyclomatic complexity of a function, you can:
def number_to_name():
number = input()
if not number.isdigit():
print("Enter a valid number")
return
number = int(number)
if number >= 10:
print("Number is too big")
return
if number == 1:
print("one")
elif number == 2:
print("two")
elif number == 3:
print("three")
elif number == 4:
print("four")
elif number == 5:
print("five")
elif number == 6:
print("six")
elif number == 7:
print("seven")
elif number == 8:
print("eight")
elif number == 9:
print("nine")
def number_to_name():
number = input()
if not number.isdigit():
print("Enter a valid number")
return
number = int(number)
if number >= 10:
print("Number is too big")
return
names = {
1: "one",
2: "two",
3: "three",
4: "four",
5: "five",
6: "six",
7: "seven",
8: "eight",
9: "nine",
}
print(names[number])
Cyclomatic complexity threshold can be configured using the
cyclomatic_complexity_threshold
meta field in the
.deepsource.toml
config file.
Configuring this is optional. If you don't provide a value, the Analyzer will
raise issues for functions with complexity higher than the default threshold,
which is medium
for the Python Analyzer.
Here's the mapping of the risk category to the cyclomatic complexity score to help you configure this better:
Risk category | Cyclomatic complexity range | Recommended action |
---|---|---|
low | 1-5 | No action needed. |
medium | 6-15 | Review and monitor. |
high | 16-25 | Review and refactor. Recommended to add comments if the function is absolutely needed to be kept as it is. |
very-high | 26-50 | Refactor to reduce the complexity. |
critical | >50 | Must refactor this. This can make the code untestable and very difficult to understand. |