File make.py has 485 lines of code (exceeds 250 allowed). Consider refactoring.

Open

# Support code for building docs (build_usage, build_man)

import glob
import os
import io

Function import_paperkey has a Cognitive Complexity of 49 (exceeds 5 allowed). Consider refactoring.

Open

    def import_paperkey(self, args):
        try:
            # imported here because it has global side effects
            import readline  # noqa
        except ImportError:

• Read up
  Read up

Function compact_segments has a Cognitive Complexity of 49 (exceeds 5 allowed). Consider refactoring.

Open

    def compact_segments(self, threshold):
        """Compact sparse segments by copying data into new segments"""
        if not self.compact:
            logger.debug("Nothing to do: compact empty")
            return

• Read up
  Read up

Function _export_tar has a Cognitive Complexity of 47 (exceeds 5 allowed). Consider refactoring.

Open

    def _export_tar(self, args, archive, tarstream):
        matcher = build_matcher(args.patterns, args.paths)

        progress = args.progress
        output_list = args.output_list

• Read up
  Read up

Function mount has a Cognitive Complexity of 46 (exceeds 5 allowed). Consider refactoring.

Open

    def mount(self, mountpoint, mount_options, foreground=False):
        """Mount filesystem on *mountpoint* with *mount_options*."""

        def pop_option(options, key, present, not_present, wanted_type, int_base=0):
            assert isinstance(options, list)  # we mutate this

• Read up
  Read up

LegacyRepository has 48 functions (exceeds 20 allowed). Consider refactoring.

Open

class LegacyRepository:
    """
    Filesystem based transactional key value store

    Transactionality is achieved by using a log (aka journal) to record changes. The log is a series of numbered files

File fs.py has 444 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import errno
import hashlib
import os
import posixpath
import re

File manifest.py has 435 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import enum
import re
from collections import namedtuple
from datetime import datetime, timedelta, timezone
from operator import attrgetter

File tar_cmds.py has 435 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import argparse
import base64
import logging
import os
import stat

Function api has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.

Open

def api(*, since, **kwargs_decorator):
    """Check version requirements and use self.call to do the remote method call.

    <since> specifies the version in which borg introduced this method.
    Calling this method when connected to an older version will fail without transmitting anything to the server.

• Read up
  Read up

Function api has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.

Open

def api(*, since, **kwargs_decorator):
    """Check version requirements and use self.call to do the remote method call.

    <since> specifies the version in which borg introduced this method.
    Calling this method when connected to an older version will fail without transmitting anything to the server.

• Read up
  Read up

File repository.py has 433 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import os
import time

from borgstore.store import Store
from borgstore.store import ObjectNotFound as StoreObjectNotFound

Function do_extract has a Cognitive Complexity of 38 (exceeds 5 allowed). Consider refactoring.

Open

    def do_extract(self, args, repository, manifest, archive):
        """Extract archive contents"""
        # be restrictive when restoring files, restore permissions later
        if sys.getfilesystemencoding() == "ascii":
            logger.warning(

• Read up
  Read up

File __init__.py has 381 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import errno
import filecmp
import io
import os
import re

Function write_options has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.

Open

    def write_options(self, parser, fp):
        def is_positional_group(group):
            return any(not o.option_strings for o in group._group_actions)

        # HTML output:

• Read up
  Read up

Function prepare_txn has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.

Open

    def prepare_txn(self, transaction_id, do_cleanup=True):
        self._active_txn = True
        if self.do_lock and not self.lock.got_exclusive_lock():
            if self.exclusive is not None:
                # self.exclusive is either True or False, thus a new client is active here.

• Read up
  Read up

File fslocking.py has 375 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import errno
import json
import os
import tempfile
import time

Function generate_level has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.

Open

    def generate_level(self, prefix, parser, Archiver, extra_choices=None):
        is_subcommand = False
        choices = {}
        for action in parser._actions:
            if action.choices is not None and "SubParsersAction" in str(action.__class__):

• Read up
  Read up

Function translate has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.

Open

def translate(pat, match_end=r"\Z"):
    """Translate a shell-style pattern to a regular expression.

    The pattern may include ``**<sep>`` (<sep> stands for the platform-specific path separator; "/" on POSIX systems)
    for matching zero or more directory levels and "*" for matching zero or more arbitrary characters except any path

• Read up
  Read up

File help_cmd.py has 362 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import collections
import functools
import textwrap

from ..constants import *  # NOQA