chrislit/abydos

View on GitHub

Showing 4,191 of 4,191 total issues

Avoid deeply nested control flow statements.
Open

                        if not (col_covered[col] | row_covered[row]):
                            break
                    else:
Severity: Major
Found in abydos/distance/_token_distance.py - About 45 mins to fix

    Avoid deeply nested control flow statements.
    Open

                            for i in range(len(self._alpha_sis_basic[k])):
                                newalpha += [
                                    _ + self._alpha_sis_basic[k][i] for _ in alpha
                                ]
                            alpha = newalpha
    Severity: Major
    Found in abydos/phonetic/_alpha_sis.py - About 45 mins to fix

      Avoid deeply nested control flow statements.
      Open

                              if (
                                  i == 0
                                  and i + 1 < elen
                                  and ename[i + 2 : i + 3] not in self._uc_v_set
                              ):
      Severity: Major
      Found in abydos/phonetic/_metaphone.py - About 45 mins to fix

        Avoid deeply nested control flow statements.
        Open

                                for row in range(n):
                                    if (
                                        not (row_covered[row])
                                        and arr[row, col] < h_val
                                    ):
        Severity: Major
        Found in abydos/distance/_token_distance.py - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                                  if is_trans:
                                      trans += self._transposition_cost_evaluator(
                                          src_cur, tar_cur
                                      )
                                  elif not ofs['trans']:
          Severity: Major
          Found in abydos/distance/_sift4_extended.py - About 45 mins to fix

            Avoid deeply nested control flow statements.
            Open

                                    if i == src_len or j == tar_len:
                                        sg_max = s_mat[i, j]
                                else:
            Severity: Major
            Found in abydos/distance/_aline.py - About 45 mins to fix

              Function sim_matrix has 6 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                  def sim_matrix(
              Severity: Minor
              Found in abydos/distance/_needleman_wunsch.py - About 45 mins to fix

                Avoid deeply nested control flow statements.
                Open

                                        if roman:
                                            if not any(
                                                abbr in fname for abbr in ('i.', 'v.', 'x.')
                                            ):
                                                full_name = (
                Severity: Major
                Found in abydos/fingerprint/_synoname_toolcode.py - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                          for key, value in src_feat[i].items():
                                              if key != 'supplemental':
                                                  src_feat[j][key] = value
                                          j = 0
                  Severity: Major
                  Found in abydos/distance/_aline.py - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                            if (
                                                abs(sp - tp) <= self._max_dist
                                                and sp not in src_matched
                                                and tp not in tar_matched
                                            ):
                    Severity: Major
                    Found in abydos/distance/_positional_q_gram_overlap.py - About 45 mins to fix

                      Avoid deeply nested control flow statements.
                      Open

                                              if not (col_covered[col] | row_covered[row]):
                                                  primed[row, col] = True
                                                  z_cols = (starred[row, :]).nonzero()[0]
                                                  if not z_cols.size:
                                                      step = 2
                      Severity: Major
                      Found in abydos/distance/_token_distance.py - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                                if (
                                                    abs(sp - tp) <= self._max_dist
                                                    and sp not in src_matched
                                                    and tp not in tar_matched
                                                ):
                        Severity: Major
                        Found in abydos/distance/_positional_q_gram_jaccard.py - About 45 mins to fix

                          Avoid deeply nested control flow statements.
                          Open

                                                  if mode == 1:
                                                      self._ordered_tokens.append(new_token)
                                                      new_token = char
                                                  else:
                                                      new_token += char
                          Severity: Major
                          Found in abydos/tokenizer/_vc_cluster.py - About 45 mins to fix

                            Function decode has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def decode(self, longval: int, nbits: int) -> str:
                                    """Decode the number to a string using the given statistics.
                            
                                    Parameters
                                    ----------
                            Severity: Minor
                            Found in abydos/compression/_arithmetic.py - About 45 mins to fix

                            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

                            Avoid deeply nested control flow statements.
                            Open

                                                    while j < lt and k < ls and src[k] == tar[j]:
                                                        j += 1
                                                        k += 1
                                                    if k - i > best:
                            Severity: Major
                            Found in abydos/distance/_iterative_substring.py - About 45 mins to fix

                              Avoid deeply nested control flow statements.
                              Open

                                                      if yang_flag[j] == 0 and _in_range(yang[j]):
                                                          if (ying[i], yang[j]) in adjwt:
                                                              n_simi += adjwt[(ying[i], yang[j])]
                                                              yang_flag[j] = 2
                                                              break
                              Severity: Major
                              Found in abydos/distance/_strcmp95.py - About 45 mins to fix

                                Avoid deeply nested control flow statements.
                                Open

                                                        if k - i > best:
                                                            best = k - i
                                                            start_src = i
                                                            end_src = k
                                                            start_tar = p
                                Severity: Major
                                Found in abydos/distance/_iterative_substring.py - About 45 mins to fix

                                  Function dist_abs has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                      def dist_abs(self, src: str, tar: str, normalized: bool = False) -> float:
                                          """Return the Minkowski distance (:math:`L^p`-norm) of two strings.
                                  
                                          Parameters
                                          ----------
                                  Severity: Minor
                                  Found in abydos/distance/_minkowski.py - About 45 mins to fix

                                  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 encode has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                      def encode(self, word: str) -> str:
                                          r"""Return the Burrows-Wheeler transformed form of a word.
                                  
                                          Parameters
                                          ----------
                                  Severity: Minor
                                  Found in abydos/compression/_bwt.py - About 45 mins to fix

                                  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

                                  Avoid deeply nested control flow statements.
                                  Open

                                                          if is_trans:
                                                              trans += 1
                                                          elif not ofs['trans']:
                                                              ofs['trans'] = True
                                                              trans += 1
                                  Severity: Major
                                  Found in abydos/distance/_sift4.py - About 45 mins to fix
                                    Severity
                                    Category
                                    Status
                                    Source
                                    Language