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 highest
UniformGridData.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 the
OneHorizon.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 you
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. |