preprocess_plot_grid has a cyclomatic complexity of 20 with "high" risk 171 return inner
172
173
174def preprocess_plot_grid(func): 175 """Decorator to set-up plot functions that plot grid data.
176
177 This decorator extends :py:func:`~.preprocess_plot` for specific functions.mismatch_from_strains has a cyclomatic complexity of 16 with "high" risk 198 return (np.amax(overlaps), overlaps.argmax())
199
200
201def mismatch_from_strains( 202 h1,
203 h2,
204 fmin=0,HierarchicalGridData._compute_component_mapping has a cyclomatic complexity of 17 with "high" risk2193 # All integers and constant
2194 return True
2195
2196 def _compute_component_mapping(self):2197 """Scan the grid structure and prepare a map between points and components.
2198
2199 :returns: Function that maps a point to the UniformGridData at highestUniformGridData.sliced has a cyclomatic complexity of 22 with "high" risk 684 # data is available. This is probably inefficient.
685 return self.evaluate_with_spline(x)
686
687 def sliced(self, cut, resample=False): 688 """Return a new :py:class:`~.UniformGridData` obtained slicing the current one.
689
690 ``cut`` specifies how to slice the data. It has to be an array with theOneHorizon.shape_outline_at_iteration has a cyclomatic complexity of 20 with "high" risk 683 }
684 return patches, origin
685
686 def shape_outline_at_iteration(self, iteration, cut): 687 """Return the cut of the 3D shape on a specified plane.
688
689 ``cut`` has to be a 3D tuple or list with None on the dimensions youA 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:
- Break the function into smaller, more manageable functions.
- Refactor complex logic into separate functions or classes.
- Avoid multiple return paths and deeply nested control expressions.
Bad practice
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")
Recommended
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])
Issue configuration
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. |