SYMBOL INDEX (2871 symbols across 192 files)

FILE: docs/conf.py
  function set_rst_settings (line 108) | def set_rst_settings(app):
  function setup (line 112) | def setup(app):

FILE: scripts/errorlist.py
  function subclasses (line 12) | def subclasses(cls):

FILE: scripts/glibc_check.py
  function parse_version (line 18) | def parse_version(v):
  function format_version (line 23) | def format_version(version):
  function main (line 27) | def main():

FILE: scripts/make.py
  function format_metavar (line 15) | def format_metavar(option):
  class BuildUsage (line 26) | class BuildUsage:
    method run (line 29) | def run(self):
    method generate_level (line 46) | def generate_level(self, prefix, parser, Archiver, extra_choices=None):
    method write_usage (line 103) | def write_usage(self, parser, fp):
    method write_options (line 113) | def write_options(self, parser, fp):
    method rows_to_table (line 164) | def rows_to_table(self, rows, write):
    method write_options_group (line 223) | def write_options_group(self, group, fp, with_title=True, base_indent=4):
  class BuildMan (line 260) | class BuildMan:
    method run (line 309) | def run(self):
    method generate_level (line 326) | def generate_level(self, prefix, parser, Archiver, extra_choices=None):
    method build_topic_pages (line 405) | def build_topic_pages(self, Archiver):
    method build_intro_page (line 416) | def build_intro_page(self):
    method new_doc (line 427) | def new_doc(self):
    method printer (line 433) | def printer(self, fd):
    method write_heading (line 439) | def write_heading(self, write, header, char="-", double_sided=False):
    method write_man_header (line 447) | def write_man_header(self, write, title, description):
    method write_examples (line 458) | def write_examples(self, write, command):
    method write_see_also (line 480) | def write_see_also(self, write, man_title):
    method gen_man_page (line 487) | def gen_man_page(self, name, rst):
    method write_usage (line 509) | def write_usage(self, write, parser):
    method write_options (line 518) | def write_options(self, write, parser):
    method write_options_group (line 527) | def write_options_group(self, write, group):
  function rm (line 574) | def rm(file):
  class Clean (line 583) | class Clean:
    method run (line 584) | def run(self):
  function usage (line 594) | def usage():
  function main (line 607) | def main(argv):

FILE: setup.py
  class Sdist (line 89) | class Sdist(sdist):
    method __init__ (line 90) | def __init__(self, *args, **kwargs):
  function members_appended (line 109) | def members_appended(*ds):
  function lib_ext_kwargs (line 123) | def lib_ext_kwargs(pc, prefix_env_var, lib_name, lib_pkg_name, pc_versio...
  function long_desc_from_readme (line 240) | def long_desc_from_readme():

FILE: src/borg/_item.c
  function PyObject (line 15) | static PyObject *
  function PyObject (line 28) | static PyObject *

FILE: src/borg/archive.py
  class Statistics (line 60) | class Statistics:
    method __init__ (line 61) | def __init__(self, output_json=False, iec=False):
    method update (line 72) | def update(self, size, unique):
    method __add__ (line 77) | def __add__(self, other):
    method __str__ (line 91) | def __str__(self):
    method __repr__ (line 118) | def __repr__(self):
    method as_dict (line 123) | def as_dict(self):
    method as_raw_dict (line 132) | def as_raw_dict(self):
    method from_raw_dict (line 136) | def from_raw_dict(cls, **kw):
    method osize_fmt (line 143) | def osize_fmt(self):
    method usize_fmt (line 147) | def usize_fmt(self):
    method show_progress (line 150) | def show_progress(self, item=None, final=False, stream=None, dt=None):
  function is_special (line 190) | def is_special(mode):
  class BackupIO (line 195) | class BackupIO:
    method __call__ (line 198) | def __call__(self, op=""):
    method __enter__ (line 202) | def __enter__(self):
    method __exit__ (line 205) | def __exit__(self, exc_type, exc_val, exc_tb):
  function backup_io_iter (line 222) | def backup_io_iter(iterator):
  function stat_update_check (line 233) | def stat_update_check(st_old, st_curr):
  function OsOpen (line 260) | def OsOpen(*, flags, path=None, parent_fd=None, name=None, noatime=False...
  class DownloadPipeline (line 271) | class DownloadPipeline:
    method __init__ (line 272) | def __init__(self, repository, repo_objs):
    method unpack_many (line 277) | def unpack_many(self, ids, *, filter=None):
    method preload_item_chunks (line 299) | def preload_item_chunks(self, item, optimize_hardlinks=False):
    method fetch_many (line 327) | def fetch_many(self, chunks, is_preloaded=False, ro_type=None, replace...
  class ChunkBuffer (line 356) | class ChunkBuffer:
    method __init__ (line 359) | def __init__(self, key, chunker_params=ITEMS_CHUNKER_PARAMS):
    method add (line 367) | def add(self, item):
    method write_chunk (line 372) | def write_chunk(self, chunk):
    method flush (line 375) | def flush(self, flush=False):
    method is_full (line 402) | def is_full(self):
  class CacheChunkBuffer (line 406) | class CacheChunkBuffer(ChunkBuffer):
    method __init__ (line 407) | def __init__(self, cache, key, stats, chunker_params=ITEMS_CHUNKER_PAR...
    method write_chunk (line 412) | def write_chunk(self, chunk):
  function get_item_uid_gid (line 421) | def get_item_uid_gid(item, *, numeric, uid_forced=None, gid_forced=None,...
  function archive_get_items (line 439) | def archive_get_items(metadata, *, repo_objs, repository):
  function archive_put_items (line 454) | def archive_put_items(chunk_ids, *, repo_objs, cache=None, stats=None, a...
  class Archive (line 472) | class Archive:
    class AlreadyExists (line 473) | class AlreadyExists(Error):
    class DoesNotExist (line 478) | class DoesNotExist(Error):
    class IncompatibleFilesystemEncodingError (line 483) | class IncompatibleFilesystemEncodingError(Error):
    method __init__ (line 488) | def __init__(
    method _load_meta (line 557) | def _load_meta(self, id):
    method load (line 568) | def load(self, id):
    method ts (line 576) | def ts(self):
    method ts_start (line 582) | def ts_start(self):
    method ts_end (line 589) | def ts_end(self):
    method fpr (line 596) | def fpr(self):
    method duration (line 600) | def duration(self):
    method duration_from_meta (line 604) | def duration_from_meta(self):
    method info (line 607) | def info(self):
    method __str__ (line 641) | def __str__(self):
    method __repr__ (line 658) | def __repr__(self):
    method item_filter (line 661) | def item_filter(self, item, filter=None):
    method iter_items (line 664) | def iter_items(self, filter=None):
    method preload_item_chunks (line 667) | def preload_item_chunks(self, item, optimize_hardlinks=False):
    method add_item (line 676) | def add_item(self, item, show_progress=True, stats=None):
    method save (line 683) | def save(self, name=None, comment=None, timestamp=None, stats=None, ad...
    method calc_stats (line 734) | def calc_stats(self, cache, want_unique=True):
    method extract_helper (line 742) | def extract_helper(self, item, path, hlm, *, dry_run=False):
    method extract_item (line 764) | def extract_item(
    method restore_attrs (line 948) | def restore_attrs(self, path, item, symlink=False, fd=None):
    method set_meta (line 1034) | def set_meta(self, key, value):
    method rename (line 1045) | def rename(self, name):
    method delete (line 1051) | def delete(self):
    method compare_archives_iter (line 1058) | def compare_archives_iter(
  class MetadataCollector (line 1113) | class MetadataCollector:
    method __init__ (line 1114) | def __init__(self, *, noatime, noctime, nobirthtime, numeric_ids, nofl...
    method stat_simple_attrs (line 1123) | def stat_simple_attrs(self, st, path, fd=None):
    method stat_ext_attrs (line 1151) | def stat_ext_attrs(self, st, path, fd=None):
    method stat_attrs (line 1170) | def stat_attrs(self, st, path, fd=None):
  function cached_hash (line 1183) | def cached_hash(chunk, id_hash):
  class ChunksProcessor (line 1202) | class ChunksProcessor:
    method __init__ (line 1205) | def __init__(self, *, key, cache, add_item, rechunkify):
    method process_file_chunks (line 1211) | def process_file_chunks(self, item, cache, stats, show_progress, chunk...
  function maybe_exclude_by_attr (line 1230) | def maybe_exclude_by_attr(item):
  class FilesystemObjectProcessors (line 1242) | class FilesystemObjectProcessors:
    method __init__ (line 1246) | def __init__(
    method create_helper (line 1277) | def create_helper(self, path, st, status=None, hardlinkable=True, stri...
    method process_dir_with_fd (line 1310) | def process_dir_with_fd(self, *, path, fd, st, strip_prefix):
    method process_dir (line 1321) | def process_dir(self, *, path, parent_fd, name, st, strip_prefix):
    method process_fifo (line 1338) | def process_fifo(self, *, path, parent_fd, name, st, strip_prefix):
    method process_dev (line 1353) | def process_dev(self, *, path, parent_fd, name, st, dev_type, strip_pr...
    method process_symlink (line 1369) | def process_symlink(self, *, path, parent_fd, name, st, strip_prefix):
    method process_pipe (line 1385) | def process_pipe(self, *, path, cache, fd, mode, user=None, group=None):
    method process_file (line 1417) | def process_file(self, *, path, parent_fd, name, st, cache, flags=flag...
  class TarfileObjectProcessors (line 1538) | class TarfileObjectProcessors:
    method __init__ (line 1539) | def __init__(
    method create_helper (line 1564) | def create_helper(self, tarinfo, status=None, type=None):
    method process_dir (line 1618) | def process_dir(self, *, tarinfo, status, type):
    method process_fifo (line 1622) | def process_fifo(self, *, tarinfo, status, type):
    method process_dev (line 1626) | def process_dev(self, *, tarinfo, status, type):
    method process_symlink (line 1631) | def process_symlink(self, *, tarinfo, status, type):
    method process_hardlink (line 1636) | def process_hardlink(self, *, tarinfo, status, type):
    method process_file (line 1648) | def process_file(self, *, tarinfo, status, type, tar):
  function valid_msgpacked_dict (line 1663) | def valid_msgpacked_dict(d, keys_serialized):
  class RobustUnpacker (line 1691) | class RobustUnpacker:
    method __init__ (line 1694) | def __init__(self, validator, item_keys):
    method resync (line 1702) | def resync(self):
    method feed (line 1706) | def feed(self, data):
    method __iter__ (line 1712) | def __iter__(self):
    method __next__ (line 1715) | def __next__(self):
  class ArchiveChecker (line 1741) | class ArchiveChecker:
    method __init__ (line 1742) | def __init__(self):
    method check (line 1746) | def check(
    method make_key (line 1815) | def make_key(self, repository, manifest_only=False):
    method verify_data (line 1852) | def verify_data(self):
    method rebuild_manifest (line 1916) | def rebuild_manifest(self):
    method rebuild_archives_directory (line 1927) | def rebuild_archives_directory(self):
    method rebuild_archives (line 1997) | def rebuild_archives(
    method finish (line 2194) | def finish(self):
  class ArchiveRecreater (line 2203) | class ArchiveRecreater:
    class Interrupted (line 2204) | class Interrupted(Exception):
      method __init__ (line 2205) | def __init__(self, metadata=None):
    method is_temporary_archive (line 2209) | def is_temporary_archive(archive_name):
    method __init__ (line 2212) | def __init__(
    method recreate (line 2252) | def recreate(self, archive_id, target_name, delete_original, comment=N...
    method process_items (line 2264) | def process_items(self, archive, target):
    method process_item (line 2278) | def process_item(self, archive, target, item):
    method process_chunks (line 2288) | def process_chunks(self, archive, target, item):
    method chunk_processor (line 2297) | def chunk_processor(self, target, chunk):
    method iter_chunks (line 2307) | def iter_chunks(self, archive, target, chunks):
    method save (line 2318) | def save(self, archive, target, comment=None, delete_original=True):
    method matcher_add_tagged_dirs (line 2337) | def matcher_add_tagged_dirs(self, archive):
    method create_target (line 2364) | def create_target(self, archive, target_name):
    method create_target_archive (line 2383) | def create_target_archive(self, name):
    method open_archive (line 2394) | def open_archive(self, archive_id, **kwargs):

FILE: src/borg/archiver/__init__.py
  class Archiver (line 100) | class Archiver(
    method __init__ (line 133) | def __init__(self, lock_wait=None, prog=None):
    method print_warning (line 138) | def print_warning(self, msg, *args, **kw):
    method print_warning_instance (line 151) | def print_warning_instance(self, warning):
    method print_file_status (line 158) | def print_file_status(self, status, path):
    method preprocess_args (line 168) | def preprocess_args(self, args):
    class CommonOptions (line 181) | class CommonOptions:
      method __init__ (line 200) | def __init__(self, define_common_options):
      method add_common_group (line 213) | def add_common_group(self, parser, provide_defaults=False):
    method build_parser (line 248) | def build_parser(self):
    method get_args (line 311) | def get_args(self, argv, cmd):
    method parse_args (line 344) | def parse_args(self, args=None):
    method get_func (line 386) | def get_func(self, args, parser):
    method prerun_checks (line 400) | def prerun_checks(self, logger, is_serve):
    method _setup_implied_logging (line 413) | def _setup_implied_logging(self, args):
    method _setup_topic_debugging (line 430) | def _setup_topic_debugging(self, args):
    method run (line 438) | def run(self, args):
  function sig_info_handler (line 500) | def sig_info_handler(sig_no, stack):  # pragma: no cover
  function sig_trace_handler (line 524) | def sig_trace_handler(sig_no, stack):  # pragma: no cover
  function format_tb (line 529) | def format_tb(exc):
  function main (line 552) | def main():  # pragma: no cover

FILE: src/borg/archiver/_common.py
  function get_repository (line 34) | def get_repository(location, *, create, exclusive, lock_wait, lock, args...
  function compat_check (line 52) | def compat_check(*, create, manifest, key, cache, compatibility, decorat...
  function with_repository (line 68) | def with_repository(
  function with_other_repository (line 153) | def with_other_repository(manifest=False, cache=False, compatibility=None):
  function with_archive (line 221) | def with_archive(method):
  function process_epilog (line 257) | def process_epilog(epilog):
  function define_exclude_and_patterns (line 271) | def define_exclude_and_patterns(add_option, *, tag_files=False, strip_co...
  function define_exclusion_group (line 336) | def define_exclusion_group(subparser, **kwargs):
  function define_archive_filters_group (line 342) | def define_archive_filters_group(
  function define_common_options (line 437) | def define_common_options(add_common_option):
  function build_matcher (line 579) | def build_matcher(inclexcl_patterns, include_paths, pattern_roots=()):
  function build_filter (line 587) | def build_filter(matcher, strip_components):

FILE: src/borg/archiver/analyze_cmd.py
  class ArchiveAnalyzer (line 19) | class ArchiveAnalyzer:
    method __init__ (line 20) | def __init__(self, args, repository, manifest):
    method analyze (line 27) | def analyze(self):
    method analyze_archives (line 33) | def analyze_archives(self) -> None:
    method analyze_archive (line 60) | def analyze_archive(self, id):
    method analyze_change (line 71) | def analyze_change(self, base, new):
    method report (line 90) | def report(self):
  class AnalyzeMixIn (line 99) | class AnalyzeMixIn:
    method do_analyze (line 101) | def do_analyze(self, args, repository, manifest):
    method build_parser_analyze (line 105) | def build_parser_analyze(self, subparsers, common_parser, mid_common_p...

FILE: src/borg/archiver/benchmark_cmd.py
  class BenchmarkMixIn (line 19) | class BenchmarkMixIn:
    method do_benchmark_crud (line 20) | def do_benchmark_crud(self, args):
    method do_benchmark_cpu (line 163) | def do_benchmark_cpu(self, args):
    method build_parser_benchmarks (line 350) | def build_parser_benchmarks(self, subparsers, common_parser, mid_commo...

FILE: src/borg/archiver/check_cmd.py
  class CheckMixIn (line 13) | class CheckMixIn:
    method do_check (line 15) | def do_check(self, args, repository):
    method build_parser_check (line 74) | def build_parser_check(self, subparsers, common_parser, mid_common_par...

FILE: src/borg/archiver/compact_cmd.py
  class ArchiveGarbageCollector (line 22) | class ArchiveGarbageCollector:
    method __init__ (line 23) | def __init__(self, repository, manifest, *, stats, iec):
    method repository_size (line 35) | def repository_size(self):
    method garbage_collect (line 40) | def garbage_collect(self):
    method get_repository_chunks (line 51) | def get_repository_chunks(self) -> ChunkIndex:
    method save_chunk_index (line 67) | def save_chunk_index(self):
    method cleanup_files_cache (line 77) | def cleanup_files_cache(self):
    method analyze_archives (line 114) | def analyze_archives(self) -> tuple[set, int, int, int]:
    method report_and_delete (line 156) | def report_and_delete(self):
  class CompactMixIn (line 208) | class CompactMixIn:
    method do_compact (line 210) | def do_compact(self, args, repository, manifest):
    method build_parser_compact (line 215) | def build_parser_compact(self, subparsers, common_parser, mid_common_p...

FILE: src/borg/archiver/completion_cmd.py
  function _attach_completion (line 630) | def _attach_completion(parser: ArgumentParser, type_class, completion_di...
  function _attach_help_completion (line 643) | def _attach_help_completion(parser: ArgumentParser, completion_dict: dict):
  class CompletionMixIn (line 655) | class CompletionMixIn:
    method do_completion (line 656) | def do_completion(self, args):
    method build_parser_completion (line 743) | def build_parser_completion(self, subparsers, common_parser, mid_commo...

FILE: src/borg/archiver/create_cmd.py
  class CreateMixIn (line 42) | class CreateMixIn:
    method do_create (line 44) | def do_create(self, args, repository, manifest):
    method _process_any (line 292) | def _process_any(self, *, path, parent_fd, name, st, fso, cache, read_...
    method _rec_walk (line 425) | def _rec_walk(
    method build_parser_create (line 575) | def build_parser_create(self, subparsers, common_parser, mid_common_pa...

FILE: src/borg/archiver/debug_cmd.py
  class DebugMixIn (line 23) | class DebugMixIn:
    method do_debug_info (line 24) | def do_debug_info(self, args):
    method do_debug_dump_archive_items (line 30) | def do_debug_dump_archive_items(self, args, repository, manifest):
    method do_debug_dump_archive (line 44) | def do_debug_dump_archive(self, args, repository, manifest):
    method do_debug_dump_manifest (line 99) | def do_debug_dump_manifest(self, args, repository, manifest):
    method do_debug_dump_repo_objs (line 111) | def do_debug_dump_repo_objs(self, args, repository):
    method do_debug_search_repo_objs (line 137) | def do_debug_search_repo_objs(self, args, repository):
    method do_debug_get_obj (line 201) | def do_debug_get_obj(self, args, repository):
    method do_debug_id_hash (line 217) | def do_debug_id_hash(self, args, repository, manifest):
    method do_debug_parse_obj (line 226) | def do_debug_parse_obj(self, args, repository, manifest):
    method do_debug_format_obj (line 249) | def do_debug_format_obj(self, args, repository, manifest):
    method do_debug_put_obj (line 273) | def do_debug_put_obj(self, args, repository):
    method do_debug_delete_obj (line 287) | def do_debug_delete_obj(self, args, repository):
    method do_debug_convert_profile (line 302) | def do_debug_convert_profile(self, args):
    method build_parser_debug (line 309) | def build_parser_debug(self, subparsers, common_parser, mid_common_par...

FILE: src/borg/archiver/delete_cmd.py
  class DeleteMixIn (line 14) | class DeleteMixIn:
    method do_delete (line 16) | def do_delete(self, args, repository):
    method build_parser_delete (line 62) | def build_parser_delete(self, subparsers, common_parser, mid_common_pa...

FILE: src/borg/archiver/diff_cmd.py
  class DiffMixIn (line 19) | class DiffMixIn:
    method do_diff (line 21) | def do_diff(self, args, repository, manifest):
    method build_parser_diff (line 173) | def build_parser_diff(self, subparsers, common_parser, mid_common_pars...

FILE: src/borg/archiver/extract_cmd.py
  class ExtractMixIn (line 22) | class ExtractMixIn:
    method do_extract (line 25) | def do_extract(self, args, repository, manifest, archive):
    method build_parser_extract (line 124) | def build_parser_extract(self, subparsers, common_parser, mid_common_p...

FILE: src/borg/archiver/help_cmd.py
  class HelpMixIn (line 9) | class HelpMixIn:
    method do_help (line 525) | def do_help(self, parser, args):
    method do_subcommand_help (line 549) | def do_subcommand_help(self, parser, args):
    method build_parser_help (line 555) | def build_parser_help(self, subparsers, common_parser, mid_common_pars...

FILE: src/borg/archiver/info_cmd.py
  class InfoMixIn (line 16) | class InfoMixIn:
    method do_info (line 18) | def do_info(self, args, repository, manifest, cache):
    method build_parser_info (line 64) | def build_parser_info(self, subparsers, common_parser, mid_common_pars...

FILE: src/borg/archiver/key_cmds.py
  class KeysMixIn (line 18) | class KeysMixIn:
    method do_key_change_passphrase (line 20) | def do_key_change_passphrase(self, args, repository, manifest):
    method do_key_change_location (line 32) | def do_key_change_location(self, args, repository, manifest, cache):
    method do_key_export (line 86) | def do_key_export(self, args, repository):
    method do_key_import (line 105) | def do_key_import(self, args, repository):
    method build_parser_keys (line 119) | def build_parser_keys(self, subparsers, common_parser, mid_common_pars...

FILE: src/borg/archiver/list_cmd.py
  class ListMixIn (line 18) | class ListMixIn:
    method do_list (line 20) | def do_list(self, args, repository, manifest):
    method build_parser_list (line 60) | def build_parser_list(self, subparsers, common_parser, mid_common_pars...

FILE: src/borg/archiver/lock_cmds.py
  class LocksMixIn (line 14) | class LocksMixIn:
    method do_with_lock (line 16) | def do_with_lock(self, args, repository):
    method do_break_lock (line 33) | def do_break_lock(self, args, repository):
    method build_parser_locks (line 38) | def build_parser_locks(self, subparsers, common_parser, mid_common_par...

FILE: src/borg/archiver/mount_cmds.py
  class MountMixIn (line 17) | class MountMixIn:
    method do_mount (line 18) | def do_mount(self, args):
    method _do_mount (line 36) | def _do_mount(self, args, repository, manifest):
    method do_umount (line 63) | def do_umount(self, args):
    method build_parser_mount_umount (line 67) | def build_parser_mount_umount(self, subparsers, common_parser, mid_com...
    method build_parser_borgfs (line 172) | def build_parser_borgfs(self, parser):
    method _define_borg_mount (line 180) | def _define_borg_mount(self, parser):

FILE: src/borg/archiver/prune_cmd.py
  function prune_within (line 19) | def prune_within(archives, seconds, kept_because):
  function default_period_func (line 31) | def default_period_func(pattern):
  function quarterly_13weekly_period_func (line 39) | def quarterly_13weekly_period_func(a):
  function quarterly_3monthly_period_func (line 60) | def quarterly_3monthly_period_func(a):
  function prune_split (line 91) | def prune_split(archives, rule, n, kept_because=None):
  class PruneMixIn (line 117) | class PruneMixIn:
    method do_prune (line 119) | def do_prune(self, args, repository, manifest):
    method build_parser_prune (line 209) | def build_parser_prune(self, subparsers, common_parser, mid_common_par...

FILE: src/borg/archiver/recreate_cmd.py
  class RecreateMixIn (line 15) | class RecreateMixIn:
    method do_recreate (line 17) | def do_recreate(self, args, repository, manifest, cache):
    method build_parser_recreate (line 57) | def build_parser_recreate(self, subparsers, common_parser, mid_common_...

FILE: src/borg/archiver/rename_cmd.py
  class RenameMixIn (line 12) | class RenameMixIn:
    method do_rename (line 15) | def do_rename(self, args, repository, manifest, cache, archive):
    method build_parser_rename (line 20) | def build_parser_rename(self, subparsers, common_parser, mid_common_pa...

FILE: src/borg/archiver/repo_compress_cmd.py
  function find_chunks (line 18) | def find_chunks(repository, repo_objs, cache, stats, ctype, clevel, olev...
  function process_chunks (line 37) | def process_chunks(repository, repo_objs, stats, recompress_ids, olevel):
  function format_compression_spec (line 75) | def format_compression_spec(ctype, clevel, olevel):
  class RepoCompressMixIn (line 87) | class RepoCompressMixIn:
    method do_repo_compress (line 89) | def do_repo_compress(self, args, repository, manifest, cache):
    method build_parser_repo_compress (line 156) | def build_parser_repo_compress(self, subparsers, common_parser, mid_co...

FILE: src/borg/archiver/repo_create_cmd.py
  class RepoCreateMixIn (line 15) | class RepoCreateMixIn:
    method do_repo_create (line 18) | def do_repo_create(self, args, repository, *, other_repository=None, o...
    method build_parser_repo_create (line 58) | def build_parser_repo_create(self, subparsers, common_parser, mid_comm...

FILE: src/borg/archiver/repo_delete_cmd.py
  class RepoDeleteMixIn (line 16) | class RepoDeleteMixIn:
    method do_repo_delete (line 18) | def do_repo_delete(self, args, repository):
    method build_parser_repo_delete (line 89) | def build_parser_repo_delete(self, subparsers, common_parser, mid_comm...

FILE: src/borg/archiver/repo_info_cmd.py
  class RepoInfoMixIn (line 14) | class RepoInfoMixIn:
    method do_repo_info (line 16) | def do_repo_info(self, args, repository, manifest, cache):
    method build_parser_repo_info (line 58) | def build_parser_repo_info(self, subparsers, common_parser, mid_common...

FILE: src/borg/archiver/repo_list_cmd.py
  class RepoListMixIn (line 16) | class RepoListMixIn:
    method do_repo_list (line 18) | def do_repo_list(self, args, repository, manifest):
    method build_parser_repo_list (line 42) | def build_parser_repo_list(self, subparsers, common_parser, mid_common...

FILE: src/borg/archiver/repo_space_cmd.py
  class RepoSpaceMixIn (line 16) | class RepoSpaceMixIn:
    method do_repo_space (line 18) | def do_repo_space(self, args, repository):
    method build_parser_repo_space (line 52) | def build_parser_repo_space(self, subparsers, common_parser, mid_commo...

FILE: src/borg/archiver/serve_cmd.py
  class ServeMixIn (line 10) | class ServeMixIn:
    method do_serve (line 11) | def do_serve(self, args):
    method build_parser_serve (line 20) | def build_parser_serve(self, subparsers, common_parser, mid_common_par...

FILE: src/borg/archiver/tag_cmd.py
  class TagMixIn (line 13) | class TagMixIn:
    method do_tag (line 15) | def do_tag(self, args, repository, manifest, cache):
    method build_parser_tag (line 44) | def build_parser_tag(self, subparsers, common_parser, mid_common_parser):

FILE: src/borg/archiver/tar_cmds.py
  function get_tar_filter (line 36) | def get_tar_filter(fname, decompress):
  class TarMixIn (line 54) | class TarMixIn:
    method do_export_tar (line 57) | def do_export_tar(self, args, repository, manifest, archive):
    method _export_tar (line 87) | def _export_tar(self, args, archive, tarstream):
    method do_import_tar (line 256) | def do_import_tar(self, args, repository, manifest, cache):
    method _import_tar (line 269) | def _import_tar(self, args, repository, manifest, key, cache, tarstream):
    method build_parser_tar (line 337) | def build_parser_tar(self, subparsers, common_parser, mid_common_parser):

FILE: src/borg/archiver/transfer_cmd.py
  function transfer_chunks (line 21) | def transfer_chunks(
  class TransferMixIn (line 130) | class TransferMixIn:
    method do_transfer (line 133) | def do_transfer(self, args, *, repository, manifest, cache, other_repo...
    method build_parser_transfer (line 272) | def build_parser_transfer(self, subparsers, common_parser, mid_common_...

FILE: src/borg/archiver/undelete_cmd.py
  class UnDeleteMixIn (line 14) | class UnDeleteMixIn:
    method do_undelete (line 16) | def do_undelete(self, args, repository):
    method build_parser_undelete (line 55) | def build_parser_undelete(self, subparsers, common_parser, mid_common_...

FILE: src/borg/archiver/version_cmd.py
  class VersionMixIn (line 11) | class VersionMixIn:
    method do_version (line 12) | def do_version(self, args):
    method build_parser_version (line 24) | def build_parser_version(self, subparsers, common_parser, mid_common_p...

FILE: src/borg/cache.py
  function files_cache_name (line 43) | def files_cache_name(archive_name, files_cache_name="files"):
  function discover_files_cache_names (line 60) | def discover_files_cache_names(path, files_cache_name="files"):
  class SecurityManager (line 75) | class SecurityManager:
    method __init__ (line 95) | def __init__(self, repository):
    method destroy (line 103) | def destroy(repository, path=None):
    method known (line 109) | def known(self):
    method key_matches (line 112) | def key_matches(self, key):
    method save (line 122) | def save(self, manifest, key):
    method assert_location_matches (line 135) | def assert_location_matches(self):
    method assert_no_manifest_replay (line 169) | def assert_no_manifest_replay(self, manifest, key):
    method assert_key_type (line 188) | def assert_key_type(self, key):
    method assert_secure (line 193) | def assert_secure(self, manifest, key, *, warn_if_unencrypted=True):
    method _assert_secure (line 200) | def _assert_secure(self, manifest, key):
    method assert_access_unknown (line 208) | def assert_access_unknown(self, warn_if_unencrypted, manifest, key):
  function assert_secure (line 233) | def assert_secure(repository, manifest):
  function cache_dir (line 238) | def cache_dir(repository, path=None):
  class CacheConfig (line 242) | class CacheConfig:
    method __init__ (line 243) | def __init__(self, repository, path=None):
    method __enter__ (line 249) | def __enter__(self):
    method __exit__ (line 253) | def __exit__(self, exc_type, exc_val, exc_tb):
    method exists (line 256) | def exists(self):
    method create (line 259) | def create(self):
    method open (line 271) | def open(self):
    method load (line 274) | def load(self):
    method save (line 300) | def save(self, manifest=None):
    method close (line 313) | def close(self):
    method _check_upgrade (line 316) | def _check_upgrade(self, config_path):
  class Cache (line 330) | class Cache:
    class CacheInitAbortedError (line 333) | class CacheInitAbortedError(Error):
    class EncryptionMethodMismatch (line 338) | class EncryptionMethodMismatch(Error):
    class RepositoryAccessAborted (line 343) | class RepositoryAccessAborted(Error):
    class RepositoryIDNotUnique (line 348) | class RepositoryIDNotUnique(Error):
    class RepositoryReplay (line 353) | class RepositoryReplay(Error):
    method break_lock (line 359) | def break_lock(repository, path=None):
    method destroy (line 363) | def destroy(repository, path=None):
    method __new__ (line 371) | def __new__(
  class FilesCacheMixin (line 396) | class FilesCacheMixin:
    method __init__ (line 408) | def __init__(self, cache_mode, archive_name=None, start_backup=None):
    method compress_entry (line 418) | def compress_entry(self, entry):
    method decompress_entry (line 441) | def decompress_entry(self, entry_packed):
    method files (line 458) | def files(self):
    method _build_files_cache (line 467) | def _build_files_cache(self):
    method files_cache_name (line 527) | def files_cache_name(self):
    method discover_files_cache_names (line 530) | def discover_files_cache_names(self, path):
    method _read_files_cache (line 533) | def _read_files_cache(self):
    method _write_files_cache (line 576) | def _write_files_cache(self, files):
    method file_known_and_unchanged (line 620) | def file_known_and_unchanged(self, hashed_path, path_hash, st):
    method memorize_file (line 676) | def memorize_file(self, hashed_path, path_hash, st, chunks):
  function list_chunkindex_hashes (line 701) | def list_chunkindex_hashes(repository):
  function delete_chunkindex_cache (line 713) | def delete_chunkindex_cache(repository):
  function write_chunkindex_to_repo_cache (line 727) | def write_chunkindex_to_repo_cache(
  function read_chunkindex_from_repo_cache (line 782) | def read_chunkindex_from_repo_cache(repository, hash):
  function build_chunkindex_from_repo (line 799) | def build_chunkindex_from_repo(repository, *, disable_caches=False, cach...
  class ChunksMixin (line 848) | class ChunksMixin:
    method __init__ (line 853) | def __init__(self):
    method chunks (line 861) | def chunks(self):
    method seen_chunk (line 866) | def seen_chunk(self, id, size=None):
    method reuse_chunk (line 879) | def reuse_chunk(self, id, size, stats):
    method add_chunk (line 884) | def add_chunk(
    method _maybe_write_chunks_cache (line 921) | def _maybe_write_chunks_cache(self, now, force=False, clear=False):
    method refresh_lock (line 927) | def refresh_lock(self, now):
  class AdHocWithFilesCache (line 935) | class AdHocWithFilesCache(FilesCacheMixin, ChunksMixin):
    method __init__ (line 946) | def __init__(
    method __enter__ (line 991) | def __enter__(self):
    method __exit__ (line 995) | def __exit__(self, exc_type, exc_val, exc_tb):
    method create (line 999) | def create(self):
    method open (line 1006) | def open(self):
    method close (line 1012) | def close(self):
    method check_cache_compatibility (line 1033) | def check_cache_compatibility(self):
    method wipe_cache (line 1045) | def wipe_cache(self):
    method update_compatibility (line 1054) | def update_compatibility(self):

FILE: src/borg/checksums.pyi
  function crc32 (line 1) | def crc32(data: bytes, value: int = 0) -> int: ...

FILE: src/borg/chunkers/__init__.py
  function get_chunker (line 8) | def get_chunker(algo, *params, **kw):

FILE: src/borg/chunkers/buzhash.pyi
  function buzhash (line 5) | def buzhash(data: bytes, seed: int) -> int: ...
  function buzhash_update (line 6) | def buzhash_update(sum: int, remove: int, add: int, len: int, seed: int)...
  class Chunker (line 8) | class Chunker:
    method __init__ (line 9) | def __init__(
    method chunkify (line 18) | def chunkify(self, fd: BinaryIO = None, fh: int = -1, fmap: List[fmap_...

FILE: src/borg/chunkers/buzhash64.pyi
  function buzhash64 (line 5) | def buzhash64(data: bytes, key: bytes) -> int: ...
  function buzhash64_update (line 6) | def buzhash64_update(sum: int, remove: int, add: int, len: int, key: byt...
  function buzhash64_get_table (line 7) | def buzhash64_get_table(key: bytes) -> List[int]: ...
  class ChunkerBuzHash64 (line 9) | class ChunkerBuzHash64:
    method __init__ (line 10) | def __init__(
    method chunkify (line 19) | def chunkify(self, fd: BinaryIO = None, fh: int = -1, fmap: List[fmap_...

FILE: src/borg/chunkers/failing.py
  class ChunkerFailing (line 9) | class ChunkerFailing:
    method __init__ (line 18) | def __init__(self, block_size: int, map: str) -> None:
    method chunkify (line 29) | def chunkify(self, fd: BinaryIO | None = None, fh: int = -1) -> Iterator:

FILE: src/borg/chunkers/fixed.py
  class ChunkerFixed (line 9) | class ChunkerFixed:
    method __init__ (line 30) | def __init__(self, block_size: int, header_size: int = 0, sparse: bool...
    method chunkify (line 38) | def chunkify(self, fd: BinaryIO | None = None, fh: int = -1, fmap: lis...

FILE: src/borg/chunkers/reader.pyi
  class _Chunk (line 5) | class _Chunk(NamedTuple):
  function Chunk (line 9) | def Chunk(data: bytes | None, **meta) -> Type[_Chunk]: ...
  function sparsemap (line 13) | def sparsemap(fd: BinaryIO = None, fh: int = -1) -> List[fmap_entry]: ...
  class FileFMAPReader (line 15) | class FileFMAPReader:
    method __init__ (line 16) | def __init__(
    method _build_fmap (line 25) | def _build_fmap(self) -> List[fmap_entry]: ...
    method blockify (line 26) | def blockify(self) -> Iterator: ...
  class FileReader (line 28) | class FileReader:
    method __init__ (line 29) | def __init__(
    method _fill_buffer (line 38) | def _fill_buffer(self) -> bool: ...
    method read (line 39) | def read(self, size: int) -> Type[_Chunk]: ...

FILE: src/borg/cockpit/app.py
  class BorgCockpitApp (line 15) | class BorgCockpitApp(App):
    method compose (line 24) | def compose(self) -> ComposeResult:
    method get_theme_variable_defaults (line 39) | def get_theme_variable_defaults(self):
    method on_load (line 49) | def on_load(self) -> None:
    method on_mount (line 54) | def on_mount(self) -> None:
    method start_runner (line 62) | def start_runner(self) -> None:
    method compute_speed (line 77) | def compute_speed(self) -> None:
    method on_unmount (line 88) | async def on_unmount(self) -> None:
    method action_quit (line 93) | async def action_quit(self) -> None:
    method action_toggle_translator (line 106) | def action_toggle_translator(self) -> None:
    method handle_log_event (line 116) | def handle_log_event(self, data: dict):

FILE: src/borg/cockpit/runner.py
  class BorgRunner (line 12) | class BorgRunner:
    method __init__ (line 17) | def __init__(self, command: List[str], log_callback: Callable[[dict], ...
    method start (line 23) | async def start(self):
    method stop (line 67) | async def stop(self):

FILE: src/borg/cockpit/translator.py
  class UniversalTranslator (line 19) | class UniversalTranslator:
    method __init__ (line 24) | def __init__(self, enabled: bool = True):
    method toggle (line 29) | def toggle(self):
    method translate (line 34) | def translate(self, message: str) -> str:

FILE: src/borg/cockpit/widgets.py
  class StatusPanel (line 17) | class StatusPanel(Static):
    method __init__ (line 27) | def __init__(self, *args, **kwargs):
    method compose (line 31) | def compose(self) -> ComposeResult:
    method update_speed (line 46) | def update_speed(self, kfiles_per_second: float):
    method watch_error_count (line 53) | def watch_error_count(self, count: int) -> None:
    method watch_files_count (line 63) | def watch_files_count(self, count: int) -> None:
    method watch_unchanged_count (line 66) | def watch_unchanged_count(self, count: int) -> None:
    method watch_modified_count (line 69) | def watch_modified_count(self, count: int) -> None:
    method watch_added_count (line 72) | def watch_added_count(self, count: int) -> None:
    method watch_other_count (line 75) | def watch_other_count(self, count: int) -> None:
    method watch_rc (line 78) | def watch_rc(self, rc: int):
    method watch_elapsed_time (line 98) | def watch_elapsed_time(self, elapsed: float) -> None:
    method refresh_ui_labels (line 112) | def refresh_ui_labels(self):
  class StandardLog (line 128) | class StandardLog(Vertical):
    method compose (line 129) | def compose(self) -> ComposeResult:
    method update_title (line 133) | def update_title(self):
    method add_line (line 136) | def add_line(self, line: str):
  class Starfield (line 183) | class Starfield(Static):
    method __init__ (line 184) | def __init__(self, *args, **kwargs):
    method on_mount (line 190) | def on_mount(self) -> None:
    method on_resize (line 193) | def on_resize(self, event) -> None:
    method _update_art (line 196) | def _update_art(self) -> None:
  class Pulsar (line 243) | class Pulsar(Static):
    method on_mount (line 248) | def on_mount(self) -> None:
    method pulse (line 252) | def pulse(self) -> None:
    method update_art (line 255) | def update_art(self) -> None:
  class Slogan (line 259) | class Slogan(Static):
    method on_mount (line 264) | def on_mount(self) -> None:
    method pulse (line 268) | def pulse(self) -> None:
    method update_slogan (line 271) | def update_slogan(self):
  class Logo (line 275) | class Logo(Static):
    method on_mount (line 287) | def on_mount(self) -> None:
  class LogoPanel (line 298) | class LogoPanel(Container):
    method __init__ (line 299) | def __init__(self, *args, **kwargs):
    method compose (line 303) | def compose(self) -> ComposeResult:
    method on_resize (line 309) | def on_resize(self, event) -> None:
  class SpeedSparkline (line 376) | class SpeedSparkline(Static):
    method __init__ (line 384) | def __init__(self, data: list[float] = None, **kwargs):
    method update_data (line 388) | def update_data(self, data: list[float]):
    method refresh_chart (line 392) | def refresh_chart(self):
    method on_resize (line 429) | def on_resize(self, event):

FILE: src/borg/compress.pyi
  function get_compressor (line 3) | def get_compressor(name: str, **kwargs) -> Any: ...
  class Compressor (line 5) | class Compressor:
    method __init__ (line 6) | def __init__(self, name: Any = ..., **kwargs) -> None: ...
    method compress (line 7) | def compress(self, meta: Dict, data: bytes) -> Tuple[Dict, bytes]: ...
    method decompress (line 8) | def decompress(self, meta: Dict, data: bytes) -> Tuple[Dict, bytes]: ...
    method detect (line 10) | def detect(data: bytes) -> Any: ...
  class CompressorBase (line 12) | class CompressorBase:
    method detect (line 16) | def detect(self, data: bytes) -> bool: ...
    method __init__ (line 17) | def __init__(self, level: int = ..., **kwargs) -> None: ...
    method decide (line 18) | def decide(self, data: bytes) -> Any: ...
    method compress (line 19) | def compress(self, data: bytes) -> bytes: ...
    method decompress (line 20) | def decompress(self, data: bytes) -> bytes: ...
  class Auto (line 22) | class Auto(CompressorBase):
    method __init__ (line 23) | def __init__(self, compressor: Any) -> None: ...
  class DecidingCompressor (line 25) | class DecidingCompressor(CompressorBase):
    method __init__ (line 26) | def __init__(self, level: int = ..., **kwargs) -> None: ...
    method decide_compress (line 27) | def decide_compress(self, data: bytes) -> Any: ...
  class CNONE (line 29) | class CNONE(CompressorBase):
    method __init__ (line 30) | def __init__(self, level: int = ..., **kwargs) -> None: ...
  class ObfuscateSize (line 32) | class ObfuscateSize(CompressorBase):
    method __init__ (line 33) | def __init__(self, level: int = ..., compressor: Any = ...) -> None: ...
  class ZLIB_legacy (line 35) | class ZLIB_legacy(CompressorBase):
    method __init__ (line 36) | def __init__(self, level: int = ..., **kwargs) -> None: ...
  class ZLIB (line 39) | class ZLIB(CompressorBase):
    method __init__ (line 40) | def __init__(self, level: int = ..., **kwargs) -> None: ...
  class LZ4 (line 43) | class LZ4(DecidingCompressor):
    method __init__ (line 44) | def __init__(self, level: int = ..., **kwargs) -> None: ...
  class LZMA (line 46) | class LZMA(DecidingCompressor):
    method __init__ (line 47) | def __init__(self, level: int = ..., **kwargs) -> None: ...
  class ZSTD (line 50) | class ZSTD(DecidingCompressor):
    method __init__ (line 51) | def __init__(self, level: int = ..., **kwargs) -> None: ...

FILE: src/borg/conftest.py
  function clean_env (line 22) | def clean_env(tmpdir_factory, monkeypatch):
  function pytest_report_header (line 37) | def pytest_report_header(config, start_path):
  function set_env_variables (line 62) | def set_env_variables():
  function backup_files (line 70) | def backup_files(tmp_path_factory):
  class ArchiverSetup (line 81) | class ArchiverSetup:
    method __init__ (line 86) | def __init__(self):
    method get_kind (line 98) | def get_kind(self) -> str:
  function archiver (line 108) | def archiver(tmp_path, set_env_variables):
  function remote_archiver (line 140) | def remote_archiver(archiver):
  function binary_archiver (line 146) | def binary_archiver(archiver):

FILE: src/borg/constants.py
  class KeyBlobStorage (line 167) | class KeyBlobStorage:
  class KeyType (line 173) | class KeyType:

FILE: src/borg/crypto/file_integrity.py
  class FileLikeWrapper (line 16) | class FileLikeWrapper:
    method __init__ (line 17) | def __init__(self, fd):
    method __enter__ (line 20) | def __enter__(self):
    method __exit__ (line 24) | def __exit__(self, exc_type, exc_val, exc_tb):
    method tell (line 27) | def tell(self):
    method seek (line 30) | def seek(self, offset, whence=io.SEEK_SET):
    method write (line 33) | def write(self, data):
    method read (line 36) | def read(self, n=None):
    method flush (line 39) | def flush(self):
    method fileno (line 42) | def fileno(self):
  class FileHashingWrapper (line 46) | class FileHashingWrapper(FileLikeWrapper):
    method __init__ (line 65) | def __init__(self, backing_fd, write):
    method __exit__ (line 70) | def __exit__(self, exc_type, exc_val, exc_tb):
    method write (line 75) | def write(self, data):
    method read (line 83) | def read(self, n=None):
    method hexdigest (line 91) | def hexdigest(self):
    method update (line 99) | def update(self, data: bytes):
    method hash_length (line 102) | def hash_length(self, seek_to_end=False):
  class SHA512FileHashingWrapper (line 109) | class SHA512FileHashingWrapper(FileHashingWrapper):
  class XXH64FileHashingWrapper (line 114) | class XXH64FileHashingWrapper(FileHashingWrapper):
  class FileIntegrityError (line 125) | class FileIntegrityError(IntegrityError):
  class IntegrityCheckedFile (line 131) | class IntegrityCheckedFile(FileLikeWrapper):
    method __init__ (line 132) | def __init__(self, path, write, filename=None, override_fd=None, integ...
    method load_integrity_data (line 155) | def load_integrity_data(self, path, integrity_data):
    method hash_filename (line 159) | def hash_filename(self, filename=None):
    method parse_integrity_data (line 171) | def parse_integrity_data(cls, path: str, data: str):
    method hash_part (line 187) | def hash_part(self, partname, is_final=False):
    method __exit__ (line 199) | def __exit__(self, exc_type, exc_val, exc_tb):
    method store_integrity_data (line 216) | def store_integrity_data(self, data: str):
  class DetachedIntegrityCheckedFile (line 220) | class DetachedIntegrityCheckedFile(IntegrityCheckedFile):
    method __init__ (line 221) | def __init__(self, path, write, filename=None, override_fd=None):
    method load_integrity_data (line 227) | def load_integrity_data(self, path, integrity_data):
    method integrity_file_path (line 232) | def integrity_file_path(path):
    method read_integrity_file (line 236) | def read_integrity_file(cls, path):
    method store_integrity_data (line 246) | def store_integrity_data(self, data: str):

FILE: src/borg/crypto/key.py
  class UnsupportedPayloadError (line 39) | class UnsupportedPayloadError(Error):
  class UnsupportedManifestError (line 45) | class UnsupportedManifestError(Error):
  class KeyfileNotFoundError (line 51) | class KeyfileNotFoundError(Error):
  class KeyfileInvalidError (line 57) | class KeyfileInvalidError(Error):
  class KeyfileMismatchError (line 63) | class KeyfileMismatchError(Error):
  class RepoKeyNotFoundError (line 69) | class RepoKeyNotFoundError(Error):
  class UnsupportedKeyFormatError (line 75) | class UnsupportedKeyFormatError(Error):
  function key_creator (line 81) | def key_creator(repository, args, *, other_key=None):
  function key_argument_names (line 90) | def key_argument_names():
  function identify_key (line 94) | def identify_key(manifest_data):
  function key_factory (line 106) | def key_factory(repository, manifest_chunk, *, other=False, ro_cls=RepoO...
  function uses_same_chunker_secret (line 112) | def uses_same_chunker_secret(other_key, key):
  function uses_same_id_hash (line 119) | def uses_same_id_hash(other_key, key):
  class KeyBase (line 145) | class KeyBase:
    method __init__ (line 179) | def __init__(self, repository):
    method id_hash (line 185) | def id_hash(self, data):
    method encrypt (line 189) | def encrypt(self, id, data):
    method decrypt (line 192) | def decrypt(self, id, data):
    method assert_id (line 195) | def assert_id(self, id, data):
    method assert_type (line 201) | def assert_type(self, type_byte, id=None):
    method derive_key (line 206) | def derive_key(self, *, salt, domain, size, from_id_key=False):
    method pack_metadata (line 221) | def pack_metadata(self, metadata_dict):
    method unpack_manifest (line 225) | def unpack_manifest(self, data):
    method unpack_archive (line 237) | def unpack_archive(self, data):
  class PlaintextKey (line 247) | class PlaintextKey(KeyBase):
    method create (line 260) | def create(cls, repository, args, **kw):
    method detect (line 265) | def detect(cls, repository, manifest_data, *, other=False):
    method id_hash (line 268) | def id_hash(self, data):
    method encrypt (line 271) | def encrypt(self, id, data):
    method decrypt (line 274) | def decrypt(self, id, data):
  function random_blake2b_256_key (line 279) | def random_blake2b_256_key():
  class ID_BLAKE2b_256 (line 293) | class ID_BLAKE2b_256:
    method id_hash (line 300) | def id_hash(self, data):
    method init_from_random_data (line 303) | def init_from_random_data(self):
  class ID_HMAC_SHA_256 (line 311) | class ID_HMAC_SHA_256:
    method id_hash (line 318) | def id_hash(self, data):
  class AESKeyBase (line 322) | class AESKeyBase(KeyBase):
    method encrypt (line 340) | def encrypt(self, id, data):
    method decrypt (line 345) | def decrypt(self, id, data):
    method init_from_given_data (line 352) | def init_from_given_data(self, *, crypt_key, id_key, chunk_seed):
    method init_from_random_data (line 360) | def init_from_random_data(self):
    method init_ciphers (line 368) | def init_ciphers(self, manifest_data=None):
  class FlexiKey (line 383) | class FlexiKey:
    method detect (line 388) | def detect(cls, repository, manifest_data, *, other=False):
    method _load (line 411) | def _load(self, key_data, passphrase):
    method decrypt_key_file (line 432) | def decrypt_key_file(self, data, passphrase):
    method pbkdf2 (line 449) | def pbkdf2(passphrase, salt, iterations, output_len_in_bytes):
    method argon2 (line 455) | def argon2(
    method decrypt_key_file_pbkdf2 (line 481) | def decrypt_key_file_pbkdf2(self, encrypted_key, passphrase):
    method decrypt_key_file_argon2 (line 488) | def decrypt_key_file_argon2(self, encrypted_key, passphrase):
    method encrypt_key_file (line 504) | def encrypt_key_file(self, data, passphrase, algorithm):
    method encrypt_key_file_pbkdf2 (line 512) | def encrypt_key_file_pbkdf2(self, data, passphrase):
    method encrypt_key_file_argon2 (line 521) | def encrypt_key_file_argon2(self, data, passphrase):
    method _save (line 534) | def _save(self, passphrase, algorithm):
    method change_passphrase (line 546) | def change_passphrase(self, passphrase=None):
    method create (line 552) | def create(cls, repository, args, *, other_key=None):
    method sanity_check (line 580) | def sanity_check(self, filename, id):
    method find_key (line 616) | def find_key(self):
    method get_existing_or_new_target (line 635) | def get_existing_or_new_target(self, args):
    method _find_key_in_keys_dir (line 644) | def _find_key_in_keys_dir(self):
    method get_new_target (line 654) | def get_new_target(self, args):
    method _find_key_file_from_environment (line 665) | def _find_key_file_from_environment(self):
    method _get_new_target_in_keys_dir (line 670) | def _get_new_target_in_keys_dir(self, args):
    method load (line 679) | def load(self, target, passphrase):
    method save (line 703) | def save(self, target, passphrase, algorithm, create=False):
    method remove (line 723) | def remove(self, target):
  class KeyfileKey (line 732) | class KeyfileKey(ID_HMAC_SHA_256, AESKeyBase, FlexiKey):
  class RepoKey (line 741) | class RepoKey(ID_HMAC_SHA_256, AESKeyBase, FlexiKey):
  class Blake2KeyfileKey (line 750) | class Blake2KeyfileKey(ID_BLAKE2b_256, AESKeyBase, FlexiKey):
  class Blake2RepoKey (line 759) | class Blake2RepoKey(ID_BLAKE2b_256, AESKeyBase, FlexiKey):
  class AuthenticatedKeyBase (line 768) | class AuthenticatedKeyBase(AESKeyBase, FlexiKey):
    method _load (line 774) | def _load(self, key_data, passphrase):
    method load (line 786) | def load(self, target, passphrase):
    method save (line 791) | def save(self, target, passphrase, algorithm, create=False):
    method init_ciphers (line 795) | def init_ciphers(self, manifest_data=None):
    method encrypt (line 799) | def encrypt(self, id, data):
    method decrypt (line 802) | def decrypt(self, id, data):
  class AuthenticatedKey (line 807) | class AuthenticatedKey(ID_HMAC_SHA_256, AuthenticatedKeyBase):
  class Blake2AuthenticatedKey (line 814) | class Blake2AuthenticatedKey(ID_BLAKE2b_256, AuthenticatedKeyBase):
  class AEADKeyBase (line 824) | class AEADKeyBase(KeyBase):
    method assert_id (line 849) | def assert_id(self, id, data):
    method encrypt (line 868) | def encrypt(self, id, data):
    method decrypt (line 878) | def decrypt(self, id, data):
    method init_from_given_data (line 890) | def init_from_given_data(self, *, crypt_key, id_key, chunk_seed):
    method init_from_random_data (line 898) | def init_from_random_data(self):
    method _get_session_key (line 906) | def _get_session_key(self, sessionid, domain=None):
    method _get_cipher (line 921) | def _get_cipher(self, sessionid, iv):
    method init_ciphers (line 927) | def init_ciphers(self, manifest_data=None, iv=0):
  class AESOCBKeyfileKey (line 933) | class AESOCBKeyfileKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
  class AESOCBRepoKey (line 942) | class AESOCBRepoKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
  class CHPOKeyfileKey (line 951) | class CHPOKeyfileKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
  class CHPORepoKey (line 960) | class CHPORepoKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
  class Blake2AESOCBKeyfileKey (line 969) | class Blake2AESOCBKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
  class Blake2AESOCBRepoKey (line 978) | class Blake2AESOCBRepoKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
  class Blake2CHPOKeyfileKey (line 987) | class Blake2CHPOKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
  class Blake2CHPORepoKey (line 996) | class Blake2CHPORepoKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):

FILE: src/borg/crypto/keymanager.py
  class NotABorgKeyFile (line 13) | class NotABorgKeyFile(Error):
  class RepoIdMismatch (line 19) | class RepoIdMismatch(Error):
  class UnencryptedRepo (line 25) | class UnencryptedRepo(Error):
  class UnknownKeyType (line 31) | class UnknownKeyType(Error):
  function sha256_truncated (line 37) | def sha256_truncated(data, num):
  class KeyManager (line 43) | class KeyManager:
    method __init__ (line 44) | def __init__(self, repository):
    method load_keyblob (line 56) | def load_keyblob(self):
    method store_keyblob (line 71) | def store_keyblob(self, args):
    method get_keyfile_data (line 80) | def get_keyfile_data(self):
    method store_keyfile (line 87) | def store_keyfile(self, target):
    method export (line 91) | def export(self, path):
    method export_qr (line 97) | def export_qr(self, path):
    method export_paperkey (line 107) | def export_paperkey(self, path):
    method import_keyfile (line 145) | def import_keyfile(self, args):
    method import_paperkey (line 159) | def import_paperkey(self, args):

FILE: src/borg/crypto/low_level.pyi
  function num_cipher_blocks (line 7) | def num_cipher_blocks(length: int, blocksize: int = 16) -> int:
  function bytes_to_int (line 11) | def bytes_to_int(x: bytes, offset: int = 0) -> int: ...
  function bytes_to_long (line 12) | def bytes_to_long(x: bytes, offset: int = 0) -> int: ...
  function long_to_bytes (line 13) | def long_to_bytes(x: int) -> bytes: ...
  function hmac_sha256 (line 14) | def hmac_sha256(key: bytes, data: bytes) -> bytes: ...
  function blake2b_256 (line 15) | def blake2b_256(key: bytes, data: bytes) -> bytes: ...
  function blake2b_128 (line 16) | def blake2b_128(data: bytes) -> bytes: ...
  class CryptoError (line 19) | class CryptoError(Exception):
  class IntegrityError (line 24) | class IntegrityError(CryptoError):
  class UNENCRYPTED (line 30) | class UNENCRYPTED:
    method __init__ (line 36) | def __init__(
    method encrypt (line 44) | def encrypt(
    method decrypt (line 47) | def decrypt(self, envelope: bytes, aad: Optional[bytes] = None) -> mem...
    method block_count (line 48) | def block_count(self, length: int) -> int: ...
    method set_iv (line 49) | def set_iv(self, iv: Union[int, bytes]) -> None: ...
    method next_iv (line 50) | def next_iv(self) -> Union[int, bytes]: ...
    method extract_iv (line 51) | def extract_iv(self, envelope: bytes) -> int: ...
  class AES256_CTR_BASE (line 53) | class AES256_CTR_BASE:
    method requirements_check (line 57) | def requirements_check(cls) -> None: ...
    method __init__ (line 58) | def __init__(
    method encrypt (line 66) | def encrypt(
    method decrypt (line 69) | def decrypt(self, envelope: bytes, aad: Optional[bytes] = None) -> byt...
    method block_count (line 70) | def block_count(self, length: int) -> int: ...
    method set_iv (line 71) | def set_iv(self, iv: Union[int, bytes]) -> None: ...
    method next_iv (line 72) | def next_iv(self) -> int: ...
    method extract_iv (line 73) | def extract_iv(self, envelope: bytes) -> int: ...
  class AES256_CTR_HMAC_SHA256 (line 75) | class AES256_CTR_HMAC_SHA256(AES256_CTR_BASE):
    method __init__ (line 78) | def __init__(
  class AES256_CTR_BLAKE2b (line 87) | class AES256_CTR_BLAKE2b(AES256_CTR_BASE):
    method __init__ (line 90) | def __init__(
  class _AEAD_BASE (line 99) | class _AEAD_BASE:
    method requirements_check (line 103) | def requirements_check(cls) -> None:
    method __init__ (line 107) | def __init__(
    method encrypt (line 110) | def encrypt(
    method decrypt (line 113) | def decrypt(self, envelope: bytes, aad: bytes = b"") -> bytes: ...
    method block_count (line 114) | def block_count(self, length: int) -> int: ...
    method set_iv (line 115) | def set_iv(self, iv: Union[int, bytes]) -> None: ...
    method next_iv (line 116) | def next_iv(self) -> int: ...
  class AES256_OCB (line 118) | class AES256_OCB(_AEAD_BASE):
    method requirements_check (line 122) | def requirements_check(cls) -> None: ...
    method __init__ (line 123) | def __init__(
  class CHACHA20_POLY1305 (line 127) | class CHACHA20_POLY1305(_AEAD_BASE):
    method requirements_check (line 131) | def requirements_check(cls) -> None: ...
    method __init__ (line 132) | def __init__(
  class AES (line 136) | class AES:
    method __init__ (line 139) | def __init__(self, enc_key: bytes, iv: Optional[Union[int, bytes]] = N...
    method encrypt (line 140) | def encrypt(self, data: bytes, iv: Optional[Union[int, bytes]] = None)...
    method decrypt (line 141) | def decrypt(self, data: bytes) -> bytes: ...
    method block_count (line 142) | def block_count(self, length: int) -> int: ...
    method set_iv (line 143) | def set_iv(self, iv: Union[int, bytes]) -> None: ...
    method next_iv (line 144) | def next_iv(self) -> int: ...
  class CSPRNG (line 146) | class CSPRNG:
    method __init__ (line 154) | def __init__(self, seed_key: bytes) -> None:
    method random_bytes (line 162) | def random_bytes(self, n: int) -> bytes:
    method random_int (line 171) | def random_int(self, n: int) -> int:
    method shuffle (line 180) | def shuffle(self, items: list) -> None:

FILE: src/borg/fslocking.py
  class TimeoutTimer (line 18) | class TimeoutTimer:
    method __init__ (line 25) | def __init__(self, timeout=None, sleep=None):
    method __repr__ (line 46) | def __repr__(self):
    method start (line 51) | def start(self):
    method sleep (line 57) | def sleep(self):
    method timed_out (line 61) | def timed_out(self):
    method timed_out_or_sleep (line 64) | def timed_out_or_sleep(self):
  class LockError (line 72) | class LockError(Error):
  class LockErrorT (line 78) | class LockErrorT(ErrorWithTraceback):
  class LockFailed (line 84) | class LockFailed(LockErrorT):
  class LockTimeout (line 90) | class LockTimeout(LockError):
  class NotLocked (line 96) | class NotLocked(LockErrorT):
  class NotMyLock (line 102) | class NotMyLock(LockErrorT):
  class ExclusiveLock (line 108) | class ExclusiveLock:
    method __init__ (line 120) | def __init__(self, path, timeout=None, sleep=None, id=None):
    method __enter__ (line 129) | def __enter__(self):
    method __exit__ (line 132) | def __exit__(self, *exc):
    method __repr__ (line 135) | def __repr__(self):
    method acquire (line 138) | def acquire(self, timeout=None, sleep=None):
    method release (line 180) | def release(self):
    method is_locked (line 201) | def is_locked(self):
    method by_me (line 204) | def by_me(self):
    method kill_stale_lock (line 207) | def kill_stale_lock(self):
    method break_lock (line 260) | def break_lock(self):
    method migrate_lock (line 266) | def migrate_lock(self, old_id, new_id):
  class LockRoster (line 277) | class LockRoster:
    method __init__ (line 285) | def __init__(self, path, id=None):
    method load (line 291) | def load(self):
    method save (line 317) | def save(self, data):
    method remove (line 321) | def remove(self):
    method get (line 327) | def get(self, key):
    method empty (line 331) | def empty(self, *keys):
    method modify (line 334) | def modify(self, key, op):
    method migrate_lock (line 354) | def migrate_lock(self, key, old_id, new_id):
  class Lock (line 374) | class Lock:
    method __init__ (line 390) | def __init__(self, path, exclusive=False, sleep=None, timeout=None, id...
    method __enter__ (line 403) | def __enter__(self):
    method __exit__ (line 406) | def __exit__(self, *exc):
    method __repr__ (line 409) | def __repr__(self):
    method acquire (line 412) | def acquire(self, exclusive=None, remove=None, sleep=None):
    method _wait_for_readers_finishing (line 427) | def _wait_for_readers_finishing(self, remove, sleep):
    method release (line 448) | def release(self):
    method upgrade (line 460) | def upgrade(self):
    method downgrade (line 466) | def downgrade(self):
    method got_exclusive_lock (line 470) | def got_exclusive_lock(self):
    method break_lock (line 473) | def break_lock(self):
    method migrate_lock (line 477) | def migrate_lock(self, old_id, new_id):

FILE: src/borg/fuse.py
  function async_wrapper (line 43) | def async_wrapper(fn):
  function async_wrapper (line 53) | def async_wrapper(fn):
  function fuse_main (line 76) | def fuse_main():
  class ItemCache (line 97) | class ItemCache:
    method __init__ (line 116) | def __init__(self, decrypted_repository):
    method get (line 154) | def get(self, inode):
    method iter_archive_items (line 178) | def iter_archive_items(self, archive_item_ids, filter=None):
  class FuseBackend (line 269) | class FuseBackend:
    method __init__ (line 272) | def __init__(self, manifest, args, decrypted_repository):
    method _create_filesystem (line 304) | def _create_filesystem(self):
    method get_item (line 326) | def get_item(self, inode):
    method check_pending_archive (line 339) | def check_pending_archive(self, inode):
    method _allocate_inode (line 345) | def _allocate_inode(self):
    method _create_dir (line 349) | def _create_dir(self, parent, mtime=None):
    method find_inode (line 360) | def find_inode(self, path, prefix=[]):
    method _process_archive (line 367) | def _process_archive(self, archive_id, prefix=[]):
    method _process_leaf (line 402) | def _process_leaf(self, name, item, parent, prefix, is_dir, item_inode...
    method _process_inner (line 467) | def _process_inner(self, name, parent_inode):
  class FuseOperations (line 478) | class FuseOperations(llfuse.Operations, FuseBackend):
    method __init__ (line 481) | def __init__(self, manifest, args, decrypted_repository):
    method sig_info_handler (line 490) | def sig_info_handler(self, sig_no, stack):
    method mount (line 516) | def mount(self, mountpoint, mount_options, foreground=False, show_rc=F...
    method statfs (line 614) | def statfs(self, ctx=None):
    method _getattr (line 627) | def _getattr(self, inode, ctx=None):
    method getattr (line 656) | def getattr(self, inode, ctx=None):
    method listxattr (line 660) | def listxattr(self, inode, ctx=None):
    method getxattr (line 665) | def getxattr(self, inode, name, ctx=None):
    method lookup (line 673) | def lookup(self, parent_inode, name, ctx=None):
    method open (line 686) | def open(self, inode, flags, ctx=None):
    method opendir (line 690) | def opendir(self, inode, ctx=None):
    method read (line 695) | def read(self, fh, offset, size):
    method readdir (line 750) | async def readdir(self, fh, off, token):  # type: ignore[misc]
    method readdir (line 760) | def readdir(self, fh, off):  # type: ignore[misc]
    method readlink (line 768) | def readlink(self, inode, ctx=None):

FILE: src/borg/hashindex.pyi
  class ChunkIndexEntry (line 5) | class ChunkIndexEntry(NamedTuple):
  class ChunkIndex (line 11) | class ChunkIndex:
    method add (line 18) | def add(self, key: bytes, size: int) -> None: ...
    method iteritems (line 19) | def iteritems(self, *, only_new: bool = ...) -> Iterator: ...
    method clear_new (line 20) | def clear_new(self) -> None: ...
    method __contains__ (line 21) | def __contains__(self, key: bytes) -> bool: ...
    method __getitem__ (line 22) | def __getitem__(self, key: bytes) -> Type[ChunkIndexEntry]: ...
    method __setitem__ (line 23) | def __setitem__(self, key: bytes, value: CIE) -> None: ...
  class NSIndex1Entry (line 25) | class NSIndex1Entry(NamedTuple):
  class NSIndex1 (line 29) | class NSIndex1:  # legacy
    method iteritems (line 30) | def iteritems(self, *args, **kwargs) -> Iterator: ...
    method __contains__ (line 31) | def __contains__(self, key: bytes) -> bool: ...
    method __getitem__ (line 32) | def __getitem__(self, key: bytes) -> Any: ...
    method __setitem__ (line 33) | def __setitem__(self, key: bytes, value: Any) -> None: ...
  class FuseVersionsIndexEntry (line 35) | class FuseVersionsIndexEntry(NamedTuple):
  class FuseVersionsIndex (line 39) | class FuseVersionsIndex:
    method __contains__ (line 40) | def __contains__(self, key: bytes) -> bool: ...
    method __getitem__ (line 41) | def __getitem__(self, key: bytes) -> Any: ...
    method __setitem__ (line 42) | def __setitem__(self, key: bytes, value: Any) -> None: ...

FILE: src/borg/helpers/__init__.py
  function add_warning (line 81) | def add_warning(msg, *args, **kwargs):
  function classify_ec (line 97) | def classify_ec(ec):
  function max_ec (line 112) | def max_ec(ec1, ec2):
  function set_ec (line 133) | def set_ec(ec):
  function init_ec_warnings (line 141) | def init_ec_warnings(ec=EXIT_SUCCESS, warnings=None):
  function get_ec (line 152) | def get_ec(ec=None):
  function get_reset_ec (line 179) | def get_reset_ec(ec=None):
  function do_show_rc (line 186) | def do_show_rc(exit_code):

FILE: src/borg/helpers/argparsing.py
  class ArgumentParser (line 107) | class ArgumentParser(_ArgumentParser):
    method __init__ (line 109) | def __init__(self, *args, formatter_class=RawDescriptionHelpFormatter,...
  function flatten_namespace (line 113) | def flatten_namespace(ns: Any) -> Namespace:

FILE: src/borg/helpers/datastruct.py
  class StableDict (line 4) | class StableDict(dict):
    method items (line 7) | def items(self):
  class Buffer (line 11) | class Buffer:
    class MemoryLimitExceeded (line 16) | class MemoryLimitExceeded(Error, OSError):
    method __init__ (line 19) | def __init__(self, allocator, size=4096, limit=None):
    method __len__ (line 30) | def __len__(self):
    method resize (line 33) | def resize(self, size, init=False):
    method get (line 45) | def get(self, size=None, init=False):
  class EfficientCollectionQueue (line 55) | class EfficientCollectionQueue:
    class SizeUnderflow (line 60) | class SizeUnderflow(Error):
    method __init__ (line 63) | def __init__(self, split_size, member_type):
    method peek_front (line 74) | def peek_front(self):
    method pop_front (line 85) | def pop_front(self, size):
    method push_back (line 103) | def push_back(self, data):
    method __len__ (line 122) | def __len__(self):
    method __bool__ (line 128) | def __bool__(self):

FILE: src/borg/helpers/errors.py
  class ErrorBase (line 11) | class ErrorBase(Exception):
    method __init__ (line 24) | def __init__(self, *args):
    method get_message (line 28) | def get_message(self):
    method exit_code (line 34) | def exit_code(self):
  class Error (line 40) | class Error(ErrorBase):
  class ErrorWithTraceback (line 44) | class ErrorWithTraceback(Error):
  class IntegrityError (line 51) | class IntegrityError(ErrorWithTraceback, IntegrityErrorBase):
  class DecompressionError (line 57) | class DecompressionError(IntegrityError):
  class CancelledByUser (line 63) | class CancelledByUser(Error):
  class RTError (line 69) | class RTError(Error):
  class CommandError (line 73) | class CommandError(Error):
  class BorgWarning (line 79) | class BorgWarning:
    method __init__ (line 88) | def __init__(self, *args):
    method get_message (line 91) | def get_message(self):
    method exit_code (line 97) | def exit_code(self):
  class FileChangedWarning (line 103) | class FileChangedWarning(BorgWarning):
  class IncludePatternNeverMatchedWarning (line 109) | class IncludePatternNeverMatchedWarning(BorgWarning):
  class BackupWarning (line 115) | class BackupWarning(BorgWarning):
    method exit_code (line 121) | def exit_code(self):
  class BackupError (line 129) | class BackupError(ErrorBase):
  class BackupRaceConditionError (line 136) | class BackupRaceConditionError(BackupError):
  class BackupOSError (line 143) | class BackupOSError(BackupError):
    method __init__ (line 155) | def __init__(self, op, os_error):
    method __str__ (line 162) | def __str__(self):
  class BackupPermissionError (line 169) | class BackupPermissionError(BackupOSError):
  class BackupIOError (line 175) | class BackupIOError(BackupOSError):
  class BackupFileNotFoundError (line 181) | class BackupFileNotFoundError(BackupOSError):
  class BackupItemExcluded (line 187) | class BackupItemExcluded(Exception):

FILE: src/borg/helpers/fs.py
  function ensure_dir (line 26) | def ensure_dir(path, mode=stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO, pr...
  function get_base_dir (line 48) | def get_base_dir(*, legacy=False):
  function join_base_dir (line 71) | def join_base_dir(*paths, **kw):
  function get_keys_dir (line 77) | def get_keys_dir(*, legacy=False, create=True):
  function get_security_dir (line 88) | def get_security_dir(repository_id=None, *, legacy=False, create=True):
  function get_data_dir (line 102) | def get_data_dir(*, legacy=False, create=True):
  function get_runtime_dir (line 113) | def get_runtime_dir(*, legacy=False, create=True):
  function get_socket_filename (line 124) | def get_socket_filename():
  function get_cache_dir (line 128) | def get_cache_dir(*, legacy=False, create=True):
  function get_config_dir (line 164) | def get_config_dir(*, legacy=False, create=True):
  function dir_is_cachedir (line 184) | def dir_is_cachedir(path=None, dir_fd=None):
  function dir_is_tagged (line 206) | def dir_is_tagged(path=None, exclude_caches=None, exclude_if_present=Non...
  function make_path_safe (line 241) | def make_path_safe(path):
  function slashify (line 270) | def slashify(path):
  function map_chars (line 294) | def map_chars(path):
  function get_strip_prefix (line 307) | def get_strip_prefix(path):
  function remove_dotdot_prefixes (line 325) | def remove_dotdot_prefixes(path):
  function assert_sanitized_path (line 342) | def assert_sanitized_path(path):
  function to_sanitized_path (line 352) | def to_sanitized_path(path):
  class HardLinkManager (line 367) | class HardLinkManager:
    method __init__ (line 392) | def __init__(self, *, id_type, info_type):
    method borg1_hardlinkable (line 397) | def borg1_hardlinkable(self, mode):  # legacy
    method borg1_hardlink_master (line 400) | def borg1_hardlink_master(self, item):  # legacy
    method borg1_hardlink_slave (line 403) | def borg1_hardlink_slave(self, item):  # legacy
    method hardlink_id_from_path (line 406) | def hardlink_id_from_path(self, path):
    method hardlink_id_from_inode (line 411) | def hardlink_id_from_inode(self, *, ino, dev):
    method remember (line 417) | def remember(self, *, id, info):
    method retrieve (line 433) | def retrieve(self, id, *, default=None):
  function scandir_keyfunc (line 441) | def scandir_keyfunc(dirent):
  function scandir_inorder (line 454) | def scandir_inorder(*, path, fd=None):
  function secure_erase (line 459) | def secure_erase(path, *, avoid_collateral_damage):
  function safe_unlink (line 480) | def safe_unlink(path):
  function dash_open (line 517) | def dash_open(path, mode):
  function O_ (line 526) | def O_(*flags):
  function os_open (line 541) | def os_open(*, flags, path=None, parent_fd=None, name=None, noatime=False):
  function os_stat (line 588) | def os_stat(*, path=None, parent_fd=None, name=None, follow_symlinks=Fal...
  function umount (line 608) | def umount(mountpoint):
  function _mkstemp_inner (line 629) | def _mkstemp_inner(dir, pre, suf, flags, output_type, mode=0o600):
  function mkstemp_mode (line 657) | def mkstemp_mode(suffix=None, prefix=None, dir=None, text=False, mode=0o...

FILE: src/borg/helpers/lrucache.py
  class LRUCache (line 9) | class LRUCache(MutableMapping[K, V]):
    method __init__ (line 22) | def __init__(self, capacity: int, dispose: Callable[[V], None] = lambd...
    method __setitem__ (line 27) | def __setitem__(self, key: K, value: V) -> None:
    method __getitem__ (line 35) | def __getitem__(self, key: K) -> V:
    method __delitem__ (line 39) | def __delitem__(self, key: K) -> None:
    method __contains__ (line 42) | def __contains__(self, key: object) -> bool:
    method __len__ (line 45) | def __len__(self) -> int:
    method replace (line 48) | def replace(self, key: K, value: V) -> None:
    method clear (line 54) | def clear(self) -> None:
    method __iter__ (line 59) | def __iter__(self) -> Iterator[K]:
    method keys (line 62) | def keys(self) -> KeysView[K]:
    method values (line 65) | def values(self) -> ValuesView[V]:
    method items (line 68) | def items(self) -> ItemsView[K, V]:

FILE: src/borg/helpers/misc.py
  function sysinfo (line 18) | def sysinfo():
  function log_multi (line 61) | def log_multi(*msgs, level=logging.INFO, logger=logger):
  class ChunkIteratorFileWrapper (line 74) | class ChunkIteratorFileWrapper:
    method __init__ (line 77) | def __init__(self, chunk_iterator, read_callback=None):
    method _refill (line 92) | def _refill(self):
    method _read (line 105) | def _read(self, nbytes):
    method read (line 113) | def read(self, nbytes):
  function open_item (line 124) | def open_item(archive, item):
  function chunkit (line 130) | def chunkit(it, size):
  function consume (line 141) | def consume(iterator, n=None):
  class ErrorIgnoringTextIOWrapper (line 152) | class ErrorIgnoringTextIOWrapper(io.TextIOWrapper):
    method read (line 153) | def read(self, n):
    method write (line 164) | def write(self, s):
  function iter_separated (line 176) | def iter_separated(fd, sep=None, read_size=4096):

FILE: src/borg/helpers/msgpack.py
  class PackException (line 73) | class PackException(Exception):
  class UnpackException (line 77) | class UnpackException(Exception):
  class Packer (line 81) | class Packer(mp_Packer):
    method __init__ (line 82) | def __init__(
    method pack (line 102) | def pack(self, obj):
  function packb (line 109) | def packb(o, *, use_bin_type=USE_BIN_TYPE, unicode_errors=UNICODE_ERRORS...
  function pack (line 117) | def pack(o, stream, *, use_bin_type=USE_BIN_TYPE, unicode_errors=UNICODE...
  class Unpacker (line 125) | class Unpacker(mp_Unpacker):
    method __init__ (line 126) | def __init__(
    method unpack (line 158) | def unpack(self):
    method __next__ (line 166) | def __next__(self):
  function unpackb (line 177) | def unpackb(packed, *, raw=RAW, unicode_errors=UNICODE_ERRORS, strict_ma...
  function unpack (line 188) | def unpack(stream, *, raw=RAW, unicode_errors=UNICODE_ERRORS, strict_map...
  function is_slow_msgpack (line 202) | def is_slow_msgpack():
  function is_supported_msgpack (line 209) | def is_supported_msgpack():
  function get_limited_unpacker (line 224) | def get_limited_unpacker(kind):
  function int_to_timestamp (line 238) | def int_to_timestamp(ns):
  function timestamp_to_int (line 243) | def timestamp_to_int(ts):

FILE: src/borg/helpers/nanorst.py
  class TextPecker (line 7) | class TextPecker:
    method __init__ (line 8) | def __init__(self, s):
    method read (line 12) | def read(self, n):
    method peek (line 16) | def peek(self, n):
    method peekline (line 22) | def peekline(self):
    method readline (line 30) | def readline(self):
  function process_directive (line 36) | def process_directive(directive, arguments, out, state_hook):
  function rst_to_text (line 51) | def rst_to_text(text, state_hook=None, references=None):
  class RstToTextLazy (line 166) | class RstToTextLazy:
    method __init__ (line 167) | def __init__(self, str, state_hook=None, references=None):
    method rst (line 174) | def rst(self):
    method __getattr__ (line 179) | def __getattr__(self, item):
    method __str__ (line 182) | def __str__(self):
    method __add__ (line 185) | def __add__(self, other):
    method __iter__ (line 188) | def __iter__(self):
    method __contains__ (line 191) | def __contains__(self, item):
  function ansi_escapes (line 195) | def ansi_escapes(old_state, new_state, out):
  function rst_to_terminal (line 204) | def rst_to_terminal(rst, references=None, destination=sys.stdout):

FILE: src/borg/helpers/parseformat.py
  function octal_int (line 40) | def octal_int(s):
  function bin_to_hex (line 46) | def bin_to_hex(binary):
  function hex_to_bin (line 50) | def hex_to_bin(hex, length=None):
  function safe_decode (line 61) | def safe_decode(s, coding="utf-8", errors="surrogateescape"):
  function safe_encode (line 68) | def safe_encode(s, coding="utf-8", errors="surrogateescape"):
  function remove_surrogates (line 75) | def remove_surrogates(s, errors="replace"):
  function binary_to_json (line 80) | def binary_to_json(key, value):
  function text_to_json (line 86) | def text_to_json(key, value):
  function join_cmd (line 114) | def join_cmd(argv, rs=False):
  function eval_escapes (line 119) | def eval_escapes(s):
  function decode_dict (line 124) | def decode_dict(d, keys, encoding="utf-8", errors="surrogateescape"):
  function interval (line 131) | def interval(s):
  class CompressionSpec (line 168) | class CompressionSpec:
    method __init__ (line 169) | def __init__(self, s):
    method compressor (line 221) | def compressor(self):
    method __str__ (line 233) | def __str__(self):
  function ChunkerParams (line 246) | def ChunkerParams(s):
  function FilesCacheMode (line 300) | def FilesCacheMode(s):
  function partial_format (line 315) | def partial_format(format, mapping):
  class DatetimeWrapper (line 329) | class DatetimeWrapper:
    method __init__ (line 330) | def __init__(self, dt):
    method __format__ (line 333) | def __format__(self, format_spec):
  class PlaceholderError (line 339) | class PlaceholderError(Error):
  class InvalidPlaceholder (line 345) | class InvalidPlaceholder(PlaceholderError):
  function format_line (line 351) | def format_line(format, data):
  function _replace_placeholders (line 363) | def _replace_placeholders(text, overrides={}):
  class PlaceholderReplacer (line 387) | class PlaceholderReplacer:
    method __init__ (line 388) | def __init__(self):
    method override (line 391) | def override(self, key, value):
    method reset (line 394) | def reset(self):
    method __call__ (line 397) | def __call__(self, text, overrides=None):
  function PathSpec (line 405) | def PathSpec(text):
  function FilesystemPathSpec (line 411) | def FilesystemPathSpec(text):
  function SortBySpec (line 417) | def SortBySpec(text):
  function format_file_size (line 426) | def format_file_size(v, precision=2, sign=False, iec=False):
  class FileSize (line 432) | class FileSize(int):
    method __new__ (line 433) | def __new__(cls, value, iec=False):
    method __format__ (line 438) | def __format__(self, format_spec):
  function parse_file_size (line 442) | def parse_file_size(s):
  function sizeof_fmt (line 459) | def sizeof_fmt(num, suffix="B", units=None, power=None, sep="", precisio...
  function sizeof_fmt_iec (line 473) | def sizeof_fmt_iec(num, suffix="B", sep="", precision=2, sign=False):
  function sizeof_fmt_decimal (line 485) | def sizeof_fmt_decimal(num, suffix="B", sep="", precision=2, sign=False):
  function format_archive (line 497) | def format_archive(archive):
  function parse_stringified_list (line 501) | def parse_stringified_list(s):
  class Location (line 506) | class Location:
    method __init__ (line 594) | def __init__(self, text="", overrides={}, other=False):
    method parse (line 610) | def parse(self, text, overrides={}):
    method _parse (line 625) | def _parse(self, text):
    method __str__ (line 670) | def __str__(self):
    method to_key_filename (line 681) | def to_key_filename(self):
    method __repr__ (line 692) | def __repr__(self):
    method host (line 696) | def host(self):
    method canonical_path (line 701) | def canonical_path(self):
    method with_timestamp (line 716) | def with_timestamp(self, timestamp):
  function location_validator (line 727) | def location_validator(proto=None, other=False):
  function relative_time_marker_validator (line 755) | def relative_time_marker_validator(text: str):
  function text_validator (line 764) | def text_validator(*, name, max_length, min_length=0, invalid_ctrl_chars...
  function tag_validator (line 791) | def tag_validator(text):
  function archivename_validator (line 798) | def archivename_validator(text):
  class BaseFormatter (line 819) | class BaseFormatter(metaclass=abc.ABCMeta):
    method __init__ (line 843) | def __init__(self, format: str, static: dict[str, Any]) -> None:
    method get_item_data (line 848) | def get_item_data(self, item, jsonline=False) -> dict:
    method format_item (line 851) | def format_item(self, item, jsonline=False, sort=False):
    method keys_help (line 858) | def keys_help(cls):
  class ArchiveFormatter (line 876) | class ArchiveFormatter(BaseFormatter):
    method __init__ (line 899) | def __init__(self, format, repository, manifest, key, *, iec=False, de...
    method get_item_data (line 924) | def get_item_data(self, archive_info, jsonline=False):
    method archive (line 946) | def archive(self):
    method get_meta (line 954) | def get_meta(self, key, default=None):
    method get_ts_start (line 957) | def get_ts_start(self):
    method get_ts_end (line 960) | def get_ts_end(self):
    method format_time (line 963) | def format_time(self, ts):
    method get_tags (line 966) | def get_tags(self):
  class ItemFormatter (line 970) | class ItemFormatter(BaseFormatter):
    method format_needs_cache (line 1011) | def format_needs_cache(cls, format):
    method __init__ (line 1015) | def __init__(self, archive, format):
    method get_item_data (line 1048) | def get_item_data(self, item, jsonline=False):
    method calculate_num_chunks (line 1087) | def calculate_num_chunks(self, item):
    method calculate_size (line 1090) | def calculate_size(self, item):
    method calculate_fingerprint (line 1094) | def calculate_fingerprint(self, item):
    method hash_item (line 1104) | def hash_item(self, hash_function, item):
    method format_time (line 1115) | def format_time(self, key, item):
    method format_iso_time (line 1118) | def format_iso_time(self, key, item):
  class DiffFormatter (line 1122) | class DiffFormatter(BaseFormatter):
    method __init__ (line 1150) | def __init__(self, format, content_only=False):
    method get_item_data (line 1176) | def get_item_data(self, item: "ItemDiff", jsonline=False) -> dict:
    method format_other (line 1193) | def format_other(self, key, diff: "ItemDiff"):
    method format_mode (line 1197) | def format_mode(self, diff: "ItemDiff", filetype=False):
    method format_owner (line 1201) | def format_owner(self, diff: "ItemDiff", spec: Literal["owner", "user"...
    method format_content (line 1220) | def format_content(self, diff: "ItemDiff"):
    method format_time (line 1236) | def format_time(self, key, diff: "ItemDiff"):
    method format_iso_time (line 1240) | def format_iso_time(self, key, diff: "ItemDiff"):
  function file_status (line 1249) | def file_status(mode):
  function clean_lines (line 1265) | def clean_lines(lines, lstrip=None, rstrip=None, remove_empty=True, remo...
  function swidth_slice (line 1292) | def swidth_slice(string, max_width):
  function ellipsis_truncate (line 1319) | def ellipsis_truncate(msg, space):
  class BorgJsonEncoder (line 1336) | class BorgJsonEncoder(json.JSONEncoder):
    method default (line 1337) | def default(self, o):
  function basic_json_data (line 1358) | def basic_json_data(manifest, *, cache=None, extra=None):
  function json_dump (line 1370) | def json_dump(obj):
  function json_print (line 1375) | def json_print(obj):
  function prepare_dump_dict (line 1379) | def prepare_dump_dict(d):
  class Highlander (line 1424) | class Highlander(Action):
    method __init__ (line 1427) | def __init__(self, *args, **kwargs):
    method __call__ (line 1431) | def __call__(self, parser, namespace, values, option_string=None):
  class MakePathSafeAction (line 1438) | class MakePathSafeAction(Highlander):
    method __call__ (line 1439) | def __call__(self, parser, namespace, path, option_string=None):

FILE: src/borg/helpers/passphrase.py
  class NoPassphraseFailure (line 18) | class NoPassphraseFailure(Error):
  class PasscommandFailure (line 24) | class PasscommandFailure(Error):
  class PassphraseWrong (line 30) | class PassphraseWrong(Error):
  class PasswordRetriesExceeded (line 36) | class PasswordRetriesExceeded(Error):
  class Passphrase (line 42) | class Passphrase(str):
    method _check_ambiguity (line 44) | def _check_ambiguity(cls, vars):
    method _env_passphrase (line 50) | def _env_passphrase(cls, env_var, default=None):
    method env_passphrase (line 56) | def env_passphrase(cls, default=None, other=False):
    method env_passcommand (line 73) | def env_passcommand(cls, default=None, other=False):
    method fd_passphrase (line 86) | def fd_passphrase(cls, other=False):
    method env_new_passphrase (line 97) | def env_new_passphrase(cls, default=None):
    method getpass (line 101) | def getpass(cls, prompt):
    method verification (line 117) | def verification(cls, passphrase):
    method display_debug_info (line 138) | def display_debug_info(passphrase):
    method new (line 164) | def new(cls, allow_empty=False):
    method __repr__ (line 186) | def __repr__(self):

FILE: src/borg/helpers/process.py
  function _daemonize (line 22) | def _daemonize():
  function daemonize (line 56) | def daemonize():
  function daemonizing (line 66) | def daemonizing(*, timeout=5, show_rc=False):
  class _ExitCodeException (line 150) | class _ExitCodeException(BaseException):
    method __init__ (line 151) | def __init__(self, exit_code):
  class SignalException (line 155) | class SignalException(BaseException):
  class SigHup (line 159) | class SigHup(SignalException):
  class SigTerm (line 163) | class SigTerm(SignalException):
  function signal_handler (line 168) | def signal_handler(sig, handler):
  function raising_signal_handler (line 190) | def raising_signal_handler(exc_cls):
  class SigIntManager (line 201) | class SigIntManager:
    method __init__ (line 202) | def __init__(self):
    method __bool__ (line 210) | def __bool__(self):
    method action_triggered (line 214) | def action_triggered(self):
    method action_done (line 218) | def action_done(self):
    method action_completed (line 222) | def action_completed(self):
    method handler (line 228) | def handler(self, sig_no, stack):
    method __enter__ (line 246) | def __enter__(self):
    method __exit__ (line 249) | def __exit__(self, exception_type, exception_value, traceback):
  function ignore_sigint (line 260) | def ignore_sigint():
  function popen_with_error_handling (line 273) | def popen_with_error_handling(cmd_line: str, log_prefix="", **kwargs):
  function is_terminal (line 304) | def is_terminal(fd=sys.stdout):
  function prepare_subprocess_env (line 308) | def prepare_subprocess_env(system, env=None):
  function create_filter_process (line 347) | def create_filter_process(cmd, stream, stream_close, inbound=True):
  class ThreadRunner (line 410) | class ThreadRunner:
    method __init__ (line 411) | def __init__(self, sleep_interval, target, *args, **kwargs):
    method _run_with_termination (line 428) | def _run_with_termination(self):
    method start (line 441) | def start(self):
    method terminate (line 448) | def terminate(self):

FILE: src/borg/helpers/progress.py
  class ProgressIndicatorBase (line 10) | class ProgressIndicatorBase:
    method operation_id (line 17) | def operation_id(cls):
    method __init__ (line 22) | def __init__(self, msgid=None):
    method make_json (line 27) | def make_json(self, *, finished=False, **kwargs):
    method finish (line 31) | def finish(self):
  class ProgressIndicatorMessage (line 36) | class ProgressIndicatorMessage(ProgressIndicatorBase):
    method output (line 39) | def output(self, msg):
  class ProgressIndicatorPercent (line 44) | class ProgressIndicatorPercent(ProgressIndicatorBase):
    method __init__ (line 47) | def __init__(self, total=0, step=5, start=0, msg="%3.0f%%", msgid=None):
    method progress (line 64) | def progress(self, current=None, increase=1):
    method show (line 73) | def show(self, current=None, increase=1, info=None):
    method output (line 88) | def output(self, message, info=None):

FILE: src/borg/helpers/shellpattern.py
  function translate (line 6) | def translate(pat, match_end=r"\Z"):
  function _parse_braces (line 71) | def _parse_braces(pat):
  function _translate_alternatives (line 108) | def _translate_alternatives(pat):

FILE: src/borg/helpers/time.py
  function parse_timestamp (line 6) | def parse_timestamp(timestamp, tzinfo=timezone.utc):
  function parse_local_timestamp (line 17) | def parse_local_timestamp(timestamp, tzinfo=None):
  function utcfromtimestampns (line 32) | def utcfromtimestampns(ts_ns: int) -> datetime:
  function timestamp (line 38) | def timestamp(s):
  function safe_s (line 78) | def safe_s(ts):
  function safe_ns (line 87) | def safe_ns(ts):
  function safe_timestamp (line 96) | def safe_timestamp(item_timestamp_ns):
  function format_time (line 101) | def format_time(ts: datetime, format_spec=""):
  function format_timedelta (line 108) | def format_timedelta(td):
  function calculate_relative_offset (line 124) | def calculate_relative_offset(format_string, from_ts, earlier=False):
  function offset_n_months (line 160) | def offset_n_months(from_ts, n_months):
  class OutputTimestamp (line 179) | class OutputTimestamp:
    method __init__ (line 180) | def __init__(self, ts: datetime):
    method __format__ (line 183) | def __format__(self, format_spec):
    method __str__ (line 187) | def __str__(self):
    method isoformat (line 190) | def isoformat(self):
  function archive_ts_now (line 197) | def archive_ts_now():

FILE: src/borg/helpers/yes_no.py
  function yes (line 15) | def yes(

FILE: src/borg/hlfuse.py
  function debug_log (line 41) | def debug_log(msg):
  class DirEntry (line 49) | class DirEntry:
    method __init__ (line 52) | def __init__(self, ino, parent=None):
    method add_child (line 57) | def add_child(self, name, child):
    method get_child (line 63) | def get_child(self, name):
    method has_child (line 69) | def has_child(self, name):
    method iter_children (line 75) | def iter_children(self):
  class FuseBackend (line 82) | class FuseBackend:
    method __init__ (line 85) | def __init__(self, manifest, args, repository):
    method _create_node (line 115) | def _create_node(self, item=None, parent=None):
    method get_inode (line 121) | def get_inode(self, ino):
    method set_inode (line 127) | def set_inode(self, ino, item):
    method _create_filesystem (line 137) | def _create_filesystem(self):
    method check_pending_archive (line 172) | def check_pending_archive(self, node):
    method _iter_archive_items (line 177) | def _iter_archive_items(self, archive_item_ids, filter=None):
    method _process_archive (line 188) | def _process_archive(self, archive_id, root_node=None):
    method _process_leaf_versioned (line 257) | def _process_leaf_versioned(self, segments, item, root_node, hlm):
    method _file_version (line 343) | def _file_version(self, item, path):
    method _make_versioned_name (line 361) | def _make_versioned_name(self, name, version):
    method _find_node_from_root (line 370) | def _find_node_from_root(self, root, path):
    method _find_node (line 383) | def _find_node(self, path):
    method _get_handle (line 407) | def _get_handle(self, node):
    method _get_node_from_handle (line 412) | def _get_node_from_handle(self, fh):
    method _make_stat_dict (line 415) | def _make_stat_dict(self, node):
  class borgfs (line 446) | class borgfs(hlfuse.Operations, FuseBackend):
    method __init__ (line 451) | def __init__(self, manifest, args, repository):
    method sig_info_handler (line 459) | def sig_info_handler(self, sig_no, stack):
    method mount (line 463) | def mount(self, mountpoint, mount_options, foreground=False, show_rc=F...
    method statfs (line 535) | def statfs(self, path):
    method getattr (line 550) | def getattr(self, path, fh=None):
    method listxattr (line 565) | def listxattr(self, path):
    method getxattr (line 575) | def getxattr(self, path, name, position=0):
    method open (line 591) | def open(self, path, fi):
    method release (line 601) | def release(self, path, fi):
    method create (line 607) | def create(self, path, mode, fi=None):
    method read (line 611) | def read(self, path, size, offset, fi):
    method readdir (line 668) | def readdir(self, path, fh=None):
    method readlink (line 690) | def readlink(self, path):

FILE: src/borg/item.pyi
  function want_bytes (line 5) | def want_bytes(v: Any, *, errors: str = ...) -> bytes: ...
  function chunks_contents_equal (line 6) | def chunks_contents_equal(chunks1: Iterator, chunks2: Iterator) -> bool:...
  class PropDict (line 8) | class PropDict:
    method __init__ (line 10) | def __init__(self, data_dict: dict = None, internal_dict: dict = None,...
    method as_dict (line 11) | def as_dict(self) -> StableDict: ...
    method get (line 12) | def get(self, key: str, default: Any = None) -> Any: ...
    method update (line 13) | def update(self, d: dict) -> None: ...
    method update_internal (line 14) | def update_internal(self, d: dict) -> None: ...
    method __contains__ (line 15) | def __contains__(self, key: str) -> bool: ...
    method __eq__ (line 16) | def __eq__(self, other: object) -> bool: ...
  class ArchiveItem (line 18) | class ArchiveItem(PropDict):
    method version (line 20) | def version(self) -> int: ...
    method version (line 22) | def version(self, val: int) -> None: ...
    method name (line 24) | def name(self) -> str: ...
    method name (line 26) | def name(self, val: str) -> None: ...
    method start (line 28) | def start(self) -> str: ...
    method start (line 30) | def start(self, val: str) -> None: ...
    method end (line 32) | def end(self) -> str: ...
    method end (line 34) | def end(self, val: str) -> None: ...
    method time (line 36) | def time(self) -> str: ...
    method time (line 38) | def time(self, val: str) -> None: ...
    method time_end (line 40) | def time_end(self) -> str: ...
    method time_end (line 42) | def time_end(self, val: str) -> None: ...
    method username (line 44) | def username(self) -> str: ...
    method username (line 46) | def username(self, val: str) -> None: ...
    method hostname (line 48) | def hostname(self) -> str: ...
    method hostname (line 50) | def hostname(self, val: str) -> None: ...
    method comment (line 52) | def comment(self) -> str: ...
    method comment (line 54) | def comment(self, val: str) -> None: ...
    method tags (line 56) | def tags(self) -> List[str]: ...
    method tags (line 58) | def tags(self, val: List[str]) -> None: ...
    method chunker_params (line 60) | def chunker_params(self) -> Tuple: ...
    method chunker_params (line 62) | def chunker_params(self, val: Tuple) -> None: ...
    method cmdline (line 64) | def cmdline(self) -> List[str]: ...
    method cmdline (line 66) | def cmdline(self, val: List[str]) -> None: ...
    method recreate_cmdline (line 68) | def recreate_cmdline(self) -> List[str]: ...
    method recreate_cmdline (line 70) | def recreate_cmdline(self, val: List[str]) -> None: ...
    method recreate_args (line 72) | def recreate_args(self) -> Any: ...
    method recreate_args (line 74) | def recreate_args(self, val: Any) -> None: ...
    method recreate_partial_chunks (line 76) | def recreate_partial_chunks(self) -> Any: ...
    method recreate_partial_chunks (line 78) | def recreate_partial_chunks(self, val: Any) -> None: ...
    method recreate_source_id (line 80) | def recreate_source_id(self) -> Any: ...
    method recreate_source_id (line 82) | def recreate_source_id(self, val: Any) -> None: ...
    method nfiles (line 84) | def nfiles(self) -> int: ...
    method nfiles (line 86) | def nfiles(self, val: int) -> None: ...
    method nfiles_parts (line 88) | def nfiles_parts(self) -> int: ...
    method nfiles_parts (line 90) | def nfiles_parts(self, val: int) -> None: ...
    method size (line 92) | def size(self) -> int: ...
    method size (line 94) | def size(self, val: int) -> None: ...
    method size_parts (line 96) | def size_parts(self) -> int: ...
    method size_parts (line 98) | def size_parts(self, val: int) -> None: ...
    method csize (line 100) | def csize(self) -> int: ...
    method csize (line 102) | def csize(self, val: int) -> None: ...
    method items (line 104) | def items(self) -> List: ...
    method items (line 106) | def items(self, val: List) -> None: ...
    method item_ptrs (line 108) | def item_ptrs(self) -> List: ...
    method item_ptrs (line 110) | def item_ptrs(self, val: List) -> None: ...
  class ChunkListEntry (line 112) | class ChunkListEntry(NamedTuple):
  class Item (line 116) | class Item(PropDict):
    method path (line 118) | def path(self) -> str: ...
    method path (line 120) | def path(self, val: str) -> None: ...
    method source (line 122) | def source(self) -> str: ...
    method source (line 124) | def source(self, val: str) -> None: ...
    method is_dir (line 125) | def is_dir(self) -> bool: ...
    method is_link (line 126) | def is_link(self) -> bool: ...
    method _is_type (line 127) | def _is_type(self, typetest: Callable) -> bool: ...
    method create_deleted (line 129) | def create_deleted(self, path) -> Item: ...
    method from_optr (line 131) | def from_optr(self, optr: Any) -> Item: ...
    method to_optr (line 132) | def to_optr(self) -> Any: ...
    method atime (line 134) | def atime(self) -> int: ...
    method atime (line 136) | def atime(self, val: int) -> None: ...
    method ctime (line 138) | def ctime(self) -> int: ...
    method ctime (line 140) | def ctime(self, val: int) -> None: ...
    method mtime (line 142) | def mtime(self) -> int: ...
    method mtime (line 144) | def mtime(self, val: int) -> None: ...
    method birthtime (line 146) | def birthtime(self) -> int: ...
    method birthtime (line 148) | def birthtime(self, val: int) -> None: ...
    method xattrs (line 150) | def xattrs(self) -> StableDict: ...
    method xattrs (line 152) | def xattrs(self, val: StableDict) -> None: ...
    method acl_access (line 154) | def acl_access(self) -> bytes: ...
    method acl_access (line 156) | def acl_access(self, val: bytes) -> None: ...
    method acl_default (line 158) | def acl_default(self) -> bytes: ...
    method acl_default (line 160) | def acl_default(self, val: bytes) -> None: ...
    method acl_extended (line 162) | def acl_extended(self) -> bytes: ...
    method acl_extended (line 164) | def acl_extended(self, val: bytes) -> None: ...
    method acl_nfs4 (line 166) | def acl_nfs4(self) -> bytes: ...
    method acl_nfs4 (line 168) | def acl_nfs4(self, val: bytes) -> None: ...
    method bsdflags (line 170) | def bsdflags(self) -> int: ...
    method bsdflags (line 172) | def bsdflags(self, val: int) -> None: ...
    method chunks (line 174) | def chunks(self) -> List: ...
    method chunks (line 176) | def chunks(self, val: List) -> None: ...
    method chunks_healthy (line 178) | def chunks_healthy(self) -> List: ...
    method chunks_healthy (line 180) | def chunks_healthy(self, val: List) -> None: ...
    method deleted (line 182) | def deleted(self) -> bool: ...
    method deleted (line 184) | def deleted(self, val: bool) -> None: ...
    method hlid (line 186) | def hlid(self) -> bytes: ...
    method hlid (line 188) | def hlid(self, val: bytes) -> None: ...
    method hardlink_master (line 190) | def hardlink_master(self) -> bool: ...
    method hardlink_master (line 192) | def hardlink_master(self, val: bool) -> None: ...
    method uid (line 194) | def uid(self) -> int: ...
    method uid (line 196) | def uid(self, val: int) -> None: ...
    method gid (line 198) | def gid(self) -> int: ...
    method gid (line 200) | def gid(self, val: int) -> None: ...
    method user (line 202) | def user(self) -> str: ...
    method user (line 204) | def user(self, val: str) -> None: ...
    method group (line 206) | def group(self) -> str: ...
    method group (line 208) | def group(self, val: str) -> None: ...
    method mode (line 210) | def mode(self) -> int: ...
    method mode (line 212) | def mode(self, val: int) -> None: ...
    method rdev (line 214) | def rdev(self) -> int: ...
    method rdev (line 216) | def rdev(self, val: int) -> None: ...
    method nlink (line 218) | def nlink(self) -> int: ...
    method nlink (line 220) | def nlink(self, val: int) -> None: ...
    method inode (line 222) | def inode(self) -> int: ...
    method inode (line 224) | def inode(self, val: int) -> None: ...
    method size (line 226) | def size(self) -> int: ...
    method size (line 228) | def size(self, val: int) -> None: ...
    method get_size (line 229) | def get_size(
    method part (line 238) | def part(self) -> int: ...
    method part (line 240) | def part(self, val: int) -> None: ...
  class ManifestItem (line 242) | class ManifestItem(PropDict):
    method version (line 244) | def version(self) -> int: ...
    method version (line 246) | def version(self, val: int) -> None: ...
    method timestamp (line 248) | def timestamp(self) -> str: ...
    method timestamp (line 250) | def timestamp(self, val: str) -> None: ...
    method archives (line 252) | def archives(self) -> Mapping[bytes, dict]: ...
    method archives (line 254) | def archives(self, val: Mapping[bytes, dict]) -> None: ...
    method config (line 256) | def config(self) -> Dict: ...
    method config (line 258) | def config(self, val: Dict) -> None: ...
    method item_keys (line 260) | def item_keys(self) -> Tuple: ...
    method item_keys (line 262) | def item_keys(self, val: Tuple) -> None: ...
  class DiffChange (line 264) | class DiffChange:
    method __init__ (line 267) | def __init__(self, diff_type: str, diff_data: Dict[str, Any] | None = ...
    method to_dict (line 268) | def to_dict(self) -> Dict[str, Any]: ...
  class ItemDiff (line 270) | class ItemDiff:
    method __init__ (line 278) | def __init__(
    method changes (line 288) | def changes(self) -> Dict[str, DiffChange]: ...
    method equal (line 289) | def equal(self, content_only: bool = ...) -> bool: ...
    method content (line 290) | def content(self) -> DiffChange | None: ...
    method ctime (line 291) | def ctime(self) -> DiffChange | None: ...
    method mtime (line 292) | def mtime(self) -> DiffChange | None: ...
    method mode (line 293) | def mode(self) -> DiffChange | None: ...
    method type (line 294) | def type(self) -> DiffChange | None: ...
    method owner (line 295) | def owner(self) -> DiffChange | None: ...
    method user (line 296) | def user(self) -> DiffChange | None: ...
    method group (line 297) | def group(self) -> DiffChange | None: ...
  function chunk_content_equal (line 299) | def chunk_content_equal(chunks_a: Iterator, chunks_b: Iterator) -> bool:...
  class Key (line 301) | class Key(PropDict):
    method version (line 303) | def version(self) -> int: ...
    method version (line 305) | def version(self, val: int) -> None: ...
    method chunk_seed (line 307) | def chunk_seed(self) -> int: ...
    method chunk_seed (line 309) | def chunk_seed(self, val: int) -> None: ...
    method tam_required (line 311) | def tam_required(self) -> bool: ...
    method tam_required (line 313) | def tam_required(self, val: bool) -> None: ...
    method enc_hmac_key (line 315) | def enc_hmac_key(self) -> bytes: ...
    method enc_hmac_key (line 317) | def enc_hmac_key(self, val: bytes) -> None: ...
    method enc_key (line 319) | def enc_key(self) -> bytes: ...
    method enc_key (line 321) | def enc_key(self, val: bytes) -> None: ...
    method id_key (line 323) | def id_key(self) -> bytes: ...
    method id_key (line 325) | def id_key(self, val: bytes) -> None: ...
    method repository_id (line 327) | def repository_id(self) -> bytes: ...
    method repository_id (line 329) | def repository_id(self, val: bytes) -> None: ...
  class EncryptedKey (line 331) | class EncryptedKey(PropDict):
    method version (line 333) | def version(self) -> int: ...
    method version (line 335) | def version(self, val: int) -> None: ...
    method algorithm (line 337) | def algorithm(self) -> str: ...
    method algorithm (line 339) | def algorithm(self, val: str) -> None: ...
    method salt (line 341) | def salt(self) -> bytes: ...
    method salt (line 343) | def salt(self, val: bytes) -> None: ...
    method iterations (line 345) | def iterations(self) -> int: ...
    method iterations (line 347) | def iterations(self, val: int) -> None: ...
    method data (line 349) | def data(self) -> bytes: ...
    method data (line 351) | def data(self, val: bytes) -> None: ...
    method hash (line 353) | def hash(self) -> bytes: ...
    method hash (line 355) | def hash(self, val: bytes) -> None: ...

FILE: src/borg/legacyremote.py
  class ConnectionClosed (line 48) | class ConnectionClosed(Error):
  class ConnectionClosedWithHint (line 54) | class ConnectionClosedWithHint(ConnectionClosed):
  class PathNotAllowed (line 60) | class PathNotAllowed(Error):
  class InvalidRPCMethod (line 66) | class InvalidRPCMethod(Error):
  class UnexpectedRPCDataFormatFromClient (line 72) | class UnexpectedRPCDataFormatFromClient(Error):
  class UnexpectedRPCDataFormatFromServer (line 78) | class UnexpectedRPCDataFormatFromServer(Error):
    method __init__ (line 83) | def __init__(self, data):
  class ConnectionBrokenWithHint (line 93) | class ConnectionBrokenWithHint(Error):
  class SleepingBandwidthLimiter (line 115) | class SleepingBandwidthLimiter:
    method __init__ (line 116) | def __init__(self, limit):
    method write (line 124) | def write(self, fd, to_send):
  function api (line 148) | def api(*, since, **kwargs_decorator):
  class LegacyRemoteRepository (line 210) | class LegacyRemoteRepository:
    class RPCError (line 213) | class RPCError(Exception):
      method __init__ (line 214) | def __init__(self, unpacked):
      method get_message (line 218) | def get_message(self):
      method traceback (line 222) | def traceback(self):
      method exception_class (line 226) | def exception_class(self):
      method exception_full (line 230) | def exception_full(self):
      method sysinfo (line 234) | def sysinfo(self):
    class RPCServerOutdated (line 237) | class RPCServerOutdated(Error):
      method method (line 243) | def method(self):
      method required_version (line 247) | def required_version(self):
    method __init__ (line 250) | def __init__(self, location, create=False, exclusive=False, lock_wait=...
    method __del__ (line 349) | def __del__(self):
    method __repr__ (line 356) | def __repr__(self):
    method __enter__ (line 359) | def __enter__(self):
    method __exit__ (line 362) | def __exit__(self, exc_type, exc_val, exc_tb):
    method id_str (line 380) | def id_str(self):
    method borg_cmd (line 383) | def borg_cmd(self, args, testing):
    method ssh_cmd (line 426) | def ssh_cmd(self, location):
    method call (line 438) | def call(self, cmd, args, **kw):
    method call_many (line 442) | def call_many(self, cmd, calls, wait=True, is_preloaded=False, async_w...
    method open (line 633) | def open(self, path, create=False, lock_wait=None, lock=True, exclusiv...
    method info (line 637) | def info(self):
    method check (line 641) | def check(self, repair=False, max_duration=0):
    method commit (line 649) | def commit(self, compact=True, threshold=0.1):
    method rollback (line 653) | def rollback(self):
    method destroy (line 657) | def destroy(self):
    method __len__ (line 661) | def __len__(self):
    method list (line 665) | def list(self, limit=None, marker=None):
    method get (line 668) | def get(self, id, read_data=True, raise_missing=True):
    method get_many (line 672) | def get_many(self, ids, read_data=True, is_preloaded=False, raise_miss...
    method put (line 677) | def put(self, id, data, wait=True):
    method delete (line 681) | def delete(self, id, wait=True):
    method save_key (line 685) | def save_key(self, keydata):
    method load_key (line 689) | def load_key(self):
    method break_lock (line 693) | def break_lock(self):
    method close (line 696) | def close(self):
    method async_response (line 713) | def async_response(self, wait=True):
    method preload (line 717) | def preload(self, ids):
    method get_manifest (line 721) | def get_manifest(self):
    method put_manifest (line 725) | def put_manifest(self, data):
  class RepositoryNoCache (line 729) | class RepositoryNoCache:
    method __init__ (line 739) | def __init__(self, repository, transform=None):
    method close (line 743) | def close(self):
    method __enter__ (line 746) | def __enter__(self):
    method __exit__ (line 749) | def __exit__(self, exc_type, exc_val, exc_tb):
    method get (line 752) | def get(self, key, read_data=True, raise_missing=True):
    method get_many (line 755) | def get_many(self, keys, read_data=True, cache=True, raise_missing=True):
    method log_instrumentation (line 759) | def log_instrumentation(self):
  class RepositoryCache (line 763) | class RepositoryCache(RepositoryNoCache):
    method __init__ (line 775) | def __init__(self, repository, pack=None, unpack=None, transform=None):
    method query_size_limit (line 791) | def query_size_limit(self):
    method prefixed_key (line 795) | def prefixed_key(self, key, complete):
    method key_filename (line 801) | def key_filename(self, key):
    method backoff (line 804) | def backoff(self):
    method add_entry (line 814) | def add_entry(self, key, data, cache, complete):
    method log_instrumentation (line 841) | def log_instrumentation(self):
    method close (line 856) | def close(self):
    method get_many (line 861) | def get_many(self, keys, read_data=True, cache=True, raise_missing=True):
  function cache_if_remote (line 894) | def cache_if_remote(repository, *, decrypted_cache=False, pack=None, unp...

FILE: src/borg/legacyrepository.py
  function header_size (line 56) | def header_size(tag):
  class LegacyRepository (line 68) | class LegacyRepository:
    class AlreadyExists (line 138) | class AlreadyExists(Error):
    class CheckNeeded (line 143) | class CheckNeeded(ErrorWithTraceback):
    class DoesNotExist (line 148) | class DoesNotExist(Error):
    class InsufficientFreeSpaceError (line 153) | class InsufficientFreeSpaceError(Error):
    class InvalidRepository (line 158) | class InvalidRepository(Error):
    class InvalidRepositoryConfig (line 163) | class InvalidRepositoryConfig(Error):
    class ObjectNotFound (line 168) | class ObjectNotFound(ErrorWithTraceback):
      method __init__ (line 173) | def __init__(self, id, repo):
    class ParentPathDoesNotExist (line 178) | class ParentPathDoesNotExist(Error):
    class PathAlreadyExists (line 183) | class PathAlreadyExists(Error):
    class PathPermissionDenied (line 190) | class PathPermissionDenied(Error):
    method __init__ (line 195) | def __init__(self, path, create=False, exclusive=False, lock_wait=None...
    method __del__ (line 228) | def __del__(self):
    method __repr__ (line 233) | def __repr__(self):
    method __enter__ (line 236) | def __enter__(self):
    method __exit__ (line 244) | def __exit__(self, exc_type, exc_val, exc_tb):
    method id_str (line 258) | def id_str(self):
    method is_repository (line 262) | def is_repository(path):
    method check_can_create_repository (line 276) | def check_can_create_repository(self, path):
    method create (line 317) | def create(self, path):
    method save_config (line 334) | def save_config(self, path, config):
    method save_key (line 373) | def save_key(self, keydata):
    method load_key (line 380) | def load_key(self):
    method destroy (line 385) | def destroy(self):
    method get_index_transaction_id (line 391) | def get_index_transaction_id(self):
    method check_transaction (line 402) | def check_transaction(self):
    method get_transaction_id (line 422) | def get_transaction_id(self):
    method break_lock (line 426) | def break_lock(self):
    method migrate_lock (line 429) | def migrate_lock(self, old_id, new_id):
    method open (line 434) | def open(self, path, exclusive, lock_wait=None, lock=True):
    method _load_hints (line 471) | def _load_hints(self):
    method info (line 479) | def info(self):
    method close (line 485) | def close(self):
    method commit (line 493) | def commit(self, compact=True, threshold=0.1):
    method _read_integrity (line 508) | def _read_integrity(self, transaction_id, key):
    method open_index (line 521) | def open_index(self, transaction_id):
    method _unpack_hints (line 529) | def _unpack_hints(self, transaction_id):
    method prepare_txn (line 535) | def prepare_txn(self, transaction_id, do_cleanup=True):
    method write_index (line 602) | def write_index(self):
    method check_free_space (line 661) | def check_free_space(self):
    method compact_segments (line 720) | def compact_segments(self, threshold):
    method replay_segments (line 895) | def replay_segments(self, index_transaction_id, segments_transaction_id):
    method _update_index (line 921) | def _update_index(self, segment, objects, report=None):
    method _rebuild_sparse (line 960) | def _rebuild_sparse(self, segment):
    method check (line 985) | def check(self, repair=False, max_duration=0):
    method _rollback (line 1116) | def _rollback(self, *, cleanup):
    method rollback (line 1123) | def rollback(self):
    method __len__ (line 1127) | def __len__(self):
    method __contains__ (line 1132) | def __contains__(self, id):
    method list (line 1137) | def list(self, limit=None, marker=None):
    method get (line 1145) | def get(self, id, read_data=True, raise_missing=True):
    method get_many (line 1157) | def get_many(self, ids, read_data=True, is_preloaded=False, raise_miss...
    method put (line 1161) | def put(self, id, data, wait=True):
    method delete (line 1184) | def delete(self, id, wait=True):
    method _delete (line 1198) | def _delete(self, id, segment, offset, size):
    method async_response (line 1211) | def async_response(self, wait=True):
    method preload (line 1222) | def preload(self, ids):
    method get_manifest (line 1225) | def get_manifest(self):
    method put_manifest (line 1231) | def put_manifest(self, data):
  class LoggedIO (line 1235) | class LoggedIO:
    class SegmentFull (line 1236) | class SegmentFull(Exception):
    method __init__ (line 1252) | def __init__(self, path, limit, segments_per_dir, capacity=90):
    method close (line 1262) | def close(self):
    method _close_fd (line 1267) | def _close_fd(self, ts_fd):
    method get_segment_dirs (line 1272) | def get_segment_dirs(self, data_dir, start_index=MIN_SEGMENT_DIR_INDEX...
    method get_segment_files (line 1283) | def get_segment_files(self, segment_dir, start_index=MIN_SEGMENT_INDEX...
    method segment_iterator (line 1294) | def segment_iterator(self, start_segment=None, end_segment=None, rever...
    method get_latest_segment (line 1318) | def get_latest_segment(self):
    method get_segments_transaction_id (line 1323) | def get_segments_transaction_id(self):
    method cleanup (line 1330) | def cleanup(self, transaction_id):
    method is_committed_segment (line 1343) | def is_committed_segment(self, segment):
    method segment_filename (line 1374) | def segment_filename(self, segment):
    method get_write_fd (line 1377) | def get_write_fd(self, no_new=False, want_new=False, raise_full=False):
    method get_fd (line 1399) | def get_fd(self, segment):
    method close_segment (line 1434) | def close_segment(self):
    method delete_segment (line 1442) | def delete_segment(self, segment):
    method clear_empty_dirs (line 1450) | def clear_empty_dirs(self):
    method segment_exists (line 1465) | def segment_exists(self, segment):
    method segment_size (line 1471) | def segment_size(self, segment):
    method get_segment_magic (line 1474) | def get_segment_magic(self, segment):
    method iter_objects (line 1479) | def iter_objects(self, segment, read_data=True):
    method recover_segment (line 1512) | def recover_segment(self, segment, filename):
    method entry_hash (line 1563) | def entry_hash(self, *data):
    method read (line 1569) | def read(self, segment, offset, id, *, read_data=True, expected_size=N...
    method _read (line 1592) | def _read(self, fd, header, segment, offset, acceptable_tags, read_dat...
    method write_put (line 1711) | def write_put(self, id, data, raise_full=False):
    method write_delete (line 1727) | def write_delete(self, id, raise_full=False):
    method write_commit (line 1735) | def write_commit(self, intermediate=False):

FILE: src/borg/logger.py
  class BorgQueueHandler (line 69) | class BorgQueueHandler(logging.handlers.QueueHandler):
    method prepare (line 72) | def prepare(self, record: logging.LogRecord) -> dict:
  class StderrHandler (line 87) | class StderrHandler(logging.StreamHandler):
    method __init__ (line 94) | def __init__(self, stream=None):
    method stream (line 98) | def stream(self):
  class TextProgressFormatter (line 102) | class TextProgressFormatter(logging.Formatter):
    method format (line 103) | def format(self, record: logging.LogRecord) -> str:
  class JSONProgressFormatter (line 110) | class JSONProgressFormatter(logging.Formatter):
    method format (line 111) | def format(self, record: logging.LogRecord) -> str:
  function _log_warning (line 126) | def _log_warning(message, category, filename, lineno, file=None, line=No...
  function remove_handlers (line 135) | def remove_handlers(logger):
  function flush_logging (line 142) | def flush_logging():
  function setup_logging (line 152) | def setup_logging(
  function find_parent_module (line 238) | def find_parent_module():
  class LazyLogger (line 257) | class LazyLogger:
    method __init__ (line 258) | def __init__(self, name=None):
    method __logger (line 263) | def __logger(self):
    method getChild (line 272) | def getChild(self, suffix):
    method setLevel (line 275) | def setLevel(self, level):
    method log (line 278) | def log(self, level, msg, *args, **kwargs):
    method exception (line 283) | def exception(self, msg, *args, exc_info=True, **kwargs):
    method debug (line 288) | def debug(self, msg, *args, **kwargs):
    method info (line 293) | def info(self, msg, *args, **kwargs):
    method warning (line 298) | def warning(self, msg, *args, **kwargs):
    method error (line 303) | def error(self, msg, *args, **kwargs):
    method critical (line 308) | def critical(self, msg, *args, **kwargs):
  function create_logger (line 314) | def create_logger(name: str = None) -> LazyLogger:
  class JsonFormatter (line 334) | class JsonFormatter(logging.Formatter):
    method format (line 351) | def format(self, record):

FILE: src/borg/manifest.py
  class MandatoryFeatureUnsupported (line 24) | class MandatoryFeatureUnsupported(Error):
  class NoManifestError (line 30) | class NoManifestError(Error):
  function filter_archives_by_date (line 43) | def filter_archives_by_date(archives, older=None, newer=None, oldest=Non...
  class Archives (line 72) | class Archives:
    method __init__ (line 81) | def __init__(self, repository, manifest):
    method prepare (line 91) | def prepare(self, manifest, m):
    method finish (line 97) | def finish(self, manifest):
    method ids (line 104) | def ids(self, *, deleted=False):
    method _get_archive_meta (line 118) | def _get_archive_meta(self, id: bytes) -> dict:
    method _infos (line 159) | def _infos(self, *, deleted=False):
    method _info_tuples (line 164) | def _info_tuples(self, *, deleted=False):
    method _matching_info_tuples (line 175) | def _matching_info_tuples(self, match_patterns, match_end, *, deleted=...
    method count (line 202) | def count(self):
    method names (line 206) | def names(self):
    method exists (line 211) | def exists(self, name):
    method exists_id (line 219) | def exists_id(self, id, *, deleted=False):
    method exists_name_and_id (line 227) | def exists_name_and_id(self, name, id):
    method exists_name_and_ts (line 240) | def exists_name_and_ts(self, name, ts):
    method _lookup_name (line 253) | def _lookup_name(self, name, raw=False):
    method get (line 273) | def get(self, name, raw=False):
    method get_by_id (line 290) | def get_by_id(self, id, raw=False, *, deleted=False):
    method create (line 321) | def create(self, name, id, ts, *, overwrite=False):
    method delete_by_id (line 335) | def delete_by_id(self, id):
    method undelete_by_id (line 341) | def undelete_by_id(self, id):
    method nuke_by_id (line 347) | def nuke_by_id(self, id):
    method list (line 353) | def list(
    method list_considering (line 404) | def list_considering(self, args):
    method get_one (line 425) | def get_one(self, match, *, match_end=r"\Z", deleted=False):
    method _set_raw_dict (line 433) | def _set_raw_dict(self, d):
    method _get_raw_dict (line 440) | def _get_raw_dict(self):
  class Manifest (line 445) | class Manifest:
    class Operation (line 447) | class Operation(enum.Enum):
    method __init__ (line 476) | def __init__(self, key, repository, item_keys=None, ro_cls=RepoObj):
    method id_str (line 486) | def id_str(self):
    method last_timestamp (line 490) | def last_timestamp(self):
    method load (line 494) | def load(cls, repository, operations, key=None, *, other=False, ro_cls...
    method check_repository_compatibility (line 518) | def check_repository_compatibility(self, operations):
    method get_all_mandatory_features (line 532) | def get_all_mandatory_features(self):
    method write (line 543) | def write(self):

FILE: src/borg/patterns.py
  function parse_patternfile_line (line 14) | def parse_patternfile_line(line, roots, ie_commands, fallback):
  function load_pattern_file (line 27) | def load_pattern_file(fileobj, roots, ie_commands, fallback=None):
  function load_exclude_file (line 34) | def load_exclude_file(fileobj, patterns):
  class ArgparsePatternAction (line 39) | class ArgparsePatternAction(Action):
    method __init__ (line 40) | def __init__(self, nargs=1, **kw):
    method __call__ (line 43) | def __call__(self, parser, args, values, option_string=None):
  class ArgparsePatternFileAction (line 47) | class ArgparsePatternFileAction(Action):
    method __init__ (line 48) | def __init__(self, nargs=1, **kw):
    method __call__ (line 51) | def __call__(self, parser, args, values, option_string=None):
    method parse (line 62) | def parse(self, fobj, args):
  class ArgparseExcludeFileAction (line 66) | class ArgparseExcludeFileAction(ArgparsePatternFileAction):
    method parse (line 67) | def parse(self, fobj, args):
  class PatternMatcher (line 71) | class PatternMatcher:
    method __init__ (line 78) | def __init__(self, fallback=None):
    method empty (line 101) | def empty(self):
    method _add (line 104) | def _add(self, pattern, cmd):
    method add (line 112) | def add(self, patterns, cmd):
    method add_includepaths (line 120) | def add_includepaths(self, include_paths):
    method get_unmatched_include_patterns (line 127) | def get_unmatched_include_patterns(self):
    method add_inclexcl (line 133) | def add_inclexcl(self, patterns):
    method match (line 138) | def match(self, path):
  function normalize_path (line 166) | def normalize_path(path):
  class PatternBase (line 173) | class PatternBase:
    method __init__ (line 178) | def __init__(self, pattern, recurse_dir=False):
    method match (line 185) | def match(self, path, normalize=True):
    method __repr__ (line 198) | def __repr__(self):
    method __str__ (line 201) | def __str__(self):
    method _prepare (line 204) | def _prepare(self, pattern):
    method _match (line 208) | def _match(self, path):
  class PathFullPattern (line 212) | class PathFullPattern(PatternBase):
    method _prepare (line 217) | def _prepare(self, pattern):
    method _match (line 220) | def _match(self, path):
  class PathPrefixPattern (line 229) | class PathPrefixPattern(PatternBase):
    method _prepare (line 238) | def _prepare(self, pattern):
    method _match (line 241) | def _match(self, path):
  class FnmatchPattern (line 245) | class FnmatchPattern(PatternBase):
    method _prepare (line 252) | def _prepare(self, pattern):
    method _match (line 264) | def _match(self, path):
  class ShellPattern (line 268) | class ShellPattern(PatternBase):
    method _prepare (line 275) | def _prepare(self, pattern):
    method _match (line 284) | def _match(self, path):
  class RegexPattern (line 288) | class RegexPattern(PatternBase):
    method _prepare (line 293) | def _prepare(self, pattern):
    method _match (line 297) | def _match(self, path):
  class IECommand (line 308) | class IECommand(Enum):
  function command_recurses_dir (line 318) | def command_recurses_dir(cmd):
  function get_pattern_class (line 323) | def get_pattern_class(prefix):
  function parse_pattern (line 330) | def parse_pattern(pattern, fallback=FnmatchPattern, recurse_dir=True):
  function parse_exclude_pattern (line 340) | def parse_exclude_pattern(pattern_str, fallback=FnmatchPattern):
  function parse_inclexcl_command (line 346) | def parse_inclexcl_command(cmd_line_str, fallback=ShellPattern):
  function get_regex_from_pattern (line 387) | def get_regex_from_pattern(pattern: str) -> str:

FILE: src/borg/platform/__init__.py
  function get_birthtime_ns (line 81) | def get_birthtime_ns(st, path, fd=None):
  function uid2user (line 95) | def uid2user(uid, default=None):
  function gid2group (line 99) | def gid2group(gid, default=None):
  function user2uid (line 103) | def user2uid(user, default=None):
  function group2gid (line 107) | def group2gid(group, default=None):

FILE: src/borg/platform/base.py
  function listxattr (line 35) | def listxattr(path, *, follow_symlinks=False):
  function getxattr (line 46) | def getxattr(path, name, *, follow_symlinks=False):
  function setxattr (line 60) | def setxattr(path, name, value, *, follow_symlinks=False):
  function acl_get (line 72) | def acl_get(path, item, st, numeric_ids=False, fd=None):
  function acl_set (line 80) | def acl_set(path, item, numeric_ids=False, fd=None):
  function set_flags (line 91) | def set_flags(path, bsd_flags, fd=None):
  function set_flags (line 96) | def set_flags(path, bsd_flags, fd=None):
  function get_flags (line 100) | def get_flags(path, st, fd=None):
  function sync_dir (line 105) | def sync_dir(path):
  function safe_fadvise (line 122) | def safe_fadvise(fd, offset, len, advice):
  class SyncFile (line 139) | class SyncFile:
    method __init__ (line 158) | def __init__(self, path, *, fd=None, binary=False):
    method __enter__ (line 175) | def __enter__(self):
    method __exit__ (line 178) | def __exit__(self, exc_type, exc_val, exc_tb):
    method write (line 181) | def write(self, data):
    method read (line 184) | def read(self, *args, **kwargs):
    method seek (line 187) | def seek(self, offset, whence=io.SEEK_SET):
    method tell (line 190) | def tell(self):
    method sync (line 193) | def sync(self):
    method close (line 206) | def close(self):
  class SaveFile (line 222) | class SaveFile:
    method __init__ (line 239) | def __init__(self, path, binary=False):
    method __enter__ (line 249) | def __enter__(self):
    method __exit__ (line 257) | def __exit__(self, exc_type, exc_val, exc_tb):
  function swidth (line 275) | def swidth(s):
  function getfqdn (line 297) | def getfqdn(name=""):
  function get_process_id (line 333) | def get_process_id():

FILE: src/borg/platform/posix_ug.py
  function _uid2user (line 7) | def _uid2user(uid, default=None):
  function _user2uid (line 15) | def _user2uid(user, default=None):
  function _gid2group (line 25) | def _gid2group(gid, default=None):
  function _group2gid (line 33) | def _group2gid(group, default=None):

FILE: src/borg/platform/windows_ug.py
  function _uid2user (line 5) | def _uid2user(uid, default=None):
  function _user2uid (line 12) | def _user2uid(user, default=None):
  function _gid2group (line 21) | def _gid2group(gid, default=None):
  function _group2gid (line 28) | def _group2gid(group, default=None):

FILE: src/borg/platform/xattr.py
  function split_string0 (line 10) | def split_string0(buf):
  function split_lstring (line 17) | def split_lstring(buf):
  class BufferTooSmallError (line 28) | class BufferTooSmallError(Exception):
  function _check (line 32) | def _check(rv, path=None, detect_buffer_too_small=False):
  function _listxattr_inner (line 58) | def _listxattr_inner(func, path):
  function _getxattr_inner (line 71) | def _getxattr_inner(func, path, name):
  function _setxattr_inner (line 85) | def _setxattr_inner(func, path, name, value):

FILE: src/borg/remote.py
  class ConnectionClosed (line 55) | class ConnectionClosed(Error):
  class ConnectionClosedWithHint (line 61) | class ConnectionClosedWithHint(ConnectionClosed):
  class PathNotAllowed (line 67) | class PathNotAllowed(Error):
  class InvalidRPCMethod (line 73) | class InvalidRPCMethod(Error):
  class UnexpectedRPCDataFormatFromClient (line 79) | class UnexpectedRPCDataFormatFromClient(Error):
  class UnexpectedRPCDataFormatFromServer (line 85) | class UnexpectedRPCDataFormatFromServer(Error):
    method __init__ (line 90) | def __init__(self, data):
  class ConnectionBrokenWithHint (line 100) | class ConnectionBrokenWithHint(Error):
  class RepositoryServer (line 122) | class RepositoryServer:  # pragma: no cover
    method __init__ (line 169) | def __init__(self, restrict_to_paths, restrict_to_repositories, use_so...
    method filter_args (line 188) | def filter_args(self, f, kwargs):
    method send_queued_log (line 193) | def send_queued_log(self):
    method serve (line 204) | def serve(self):
    method negotiate (line 345) | def negotiate(self, client_data):
    method _resolve_path (line 354) | def _resolve_path(self, path):
    method open (line 360) | def open(self, path, create=False, lock_wait=None, lock=True, exclusiv...
    method close (line 391) | def close(self):
    method inject_exception (line 398) | def inject_exception(self, kind):
  class SleepingBandwidthLimiter (line 421) | class SleepingBandwidthLimiter:
    method __init__ (line 422) | def __init__(self, limit):
    method write (line 430) | def write(self, fd, to_send):
  function api (line 454) | def api(*, since, **kwargs_decorator):
  class RemoteRepository (line 516) | class RemoteRepository:
    class RPCError (line 519) | class RPCError(Exception):
      method __init__ (line 520) | def __init__(self, unpacked):
      method get_message (line 524) | def get_message(self):
      method traceback (line 528) | def traceback(self):
      method exception_class (line 532) | def exception_class(self):
      method exception_full (line 536) | def exception_full(self):
      method sysinfo (line 540) | def sysinfo(self):
    class RPCServerOutdated (line 543) | class RPCServerOutdated(Error):
      method method (line 549) | def method(self):
      method required_version (line 553) | def required_version(self):
    method __init__ (line 556) | def __init__(self, location, create=False, exclusive=False, lock_wait=...
    method __del__ (line 650) | def __del__(self):
    method __repr__ (line 657) | def __repr__(self):
    method __enter__ (line 660) | def __enter__(self):
    method __exit__ (line 663) | def __exit__(self, exc_type, exc_val, exc_tb):
    method id_str (line 678) | def id_str(self):
    method borg_cmd (line 681) | def borg_cmd(self, args, testing):
    method ssh_cmd (line 724) | def ssh_cmd(self, location):
    method call (line 736) | def call(self, cmd, args, **kw):
    method call_many (line 740) | def call_many(self, cmd, calls, wait=True, is_preloaded=False, async_w...
    method open (line 950) | def open(self, path, create=False, lock_wait=None, lock=True, exclusiv...
    method info (line 954) | def info(self):
    method check (line 958) | def check(self, repair=False, max_duration=0):
    method commit (line 966) | def commit(self, compact=True, threshold=0.1):
    method rollback (line 970) | def rollback(self):
    method destroy (line 974) | def destroy(self):
    method __len__ (line 978) | def __len__(self):
    method list (line 982) | def list(self, limit=None, marker=None):
    method get (line 985) | def get(self, id, read_data=True, raise_missing=True):
    method get_many (line 989) | def get_many(self, ids, read_data=True, is_preloaded=False, raise_miss...
    method put (line 997) | def put(self, id, data, wait=True):
    method delete (line 1001) | def delete(self, id, wait=True):
    method save_key (line 1005) | def save_key(self, keydata):
    method load_key (line 1009) | def load_key(self):
    method break_lock (line 1013) | def break_lock(self):
    method close (line 1016) | def close(self):
    method async_response (line 1033) | def async_response(self, wait=True):
    method preload (line 1037) | def preload(self, ids):
    method get_manifest (line 1041) | def get_manifest(self):
    method put_manifest (line 1045) | def put_manifest(self, data):
    method store_list (line 1049) | def store_list(self, name, *, deleted=False):
    method store_load (line 1053) | def store_load(self, name):
    method store_store (line 1057) | def store_store(self, name, value):
    method store_delete (line 1061) | def store_delete(self, name, *, deleted=False):
    method store_move (line 1065) | def store_move(self, name, new_name=None, *, delete=False, undelete=Fa...
  class RepositoryNoCache (line 1069) | class RepositoryNoCache:
    method __init__ (line 1079) | def __init__(self, repository, transform=None):
    method close (line 1083) | def close(self):
    method __enter__ (line 1086) | def __enter__(self):
    method __exit__ (line 1089) | def __exit__(self, exc_type, exc_val, exc_tb):
    method get (line 1092) | def get(self, key, read_data=True, raise_missing=True):
    method get_many (line 1095) | def get_many(self, keys, read_data=True, raise_missing=True, cache=True):
    method log_instrumentation (line 1099) | def log_instrumentation(self):
  class RepositoryCache (line 1103) | class RepositoryCache(RepositoryNoCache):
    method __init__ (line 1115) | def __init__(self, repository, pack=None, unpack=None, transform=None):
    method query_size_limit (line 1131) | def query_size_limit(self):
    method prefixed_key (line 1135) | def prefixed_key(self, key, complete):
    method key_filename (line 1141) | def key_filename(self, key):
    method backoff (line 1144) | def backoff(self):
    method add_entry (line 1154) | def add_entry(self, key, data, cache, complete):
    method log_instrumentation (line 1181) | def log_instrumentation(self):
    method close (line 1196) | def close(self):
    method get_many (line 1201) | def get_many(self, keys, read_data=True, raise_missing=True, cache=True):
  function cache_if_remote (line 1234) | def cache_if_remote(repository, *, decrypted_cache=False, pack=None, unp...

FILE: src/borg/repoobj.py
  class RepoObj (line 15) | class RepoObj:
    method extract_crypted_data (line 22) | def extract_crypted_data(cls, data: bytes) -> bytes:
    method __init__ (line 28) | def __init__(self, key):
    method id_hash (line 34) | def id_hash(self, data: bytes) -> bytes:
    method format (line 37) | def format(
    method parse_meta (line 76) | def parse_meta(self, id: bytes, cdata: bytes, ro_type: str) -> dict:
    method parse (line 93) | def parse(
  class RepoObj1 (line 142) | class RepoObj1:  # legacy
    method extract_crypted_data (line 144) | def extract_crypted_data(cls, data: bytes) -> bytes:
    method __init__ (line 148) | def __init__(self, key):
    method id_hash (line 152) | def id_hash(self, data: bytes) -> bytes:
    method format (line 155) | def format(
    method parse_meta (line 180) | def parse_meta(self, id: bytes, cdata: bytes) -> dict:
    method parse (line 183) | def parse(

FILE: src/borg/repository.py
  function repo_lister (line 26) | def repo_lister(repository, *, limit=None):
  class Repository (line 37) | class Repository:
    class AlreadyExists (line 40) | class AlreadyExists(Error):
    class CheckNeeded (line 45) | class CheckNeeded(ErrorWithTraceback):
    class DoesNotExist (line 50) | class DoesNotExist(Error):
    class InsufficientFreeSpaceError (line 55) | class InsufficientFreeSpaceError(Error):
    class InvalidRepository (line 60) | class InvalidRepository(Error):
    class InvalidRepositoryConfig (line 65) | class InvalidRepositoryConfig(Error):
    class ObjectNotFound (line 70) | class ObjectNotFound(ErrorWithTraceback):
      method __init__ (line 75) | def __init__(self, id, repo):
    class ParentPathDoesNotExist (line 80) | class ParentPathDoesNotExist(Error):
    class PathAlreadyExists (line 85) | class PathAlreadyExists(Error):
    class PathPermissionDenied (line 92) | class PathPermissionDenied(Error):
    method __init__ (line 97) | def __init__(
    method __repr__ (line 181) | def __repr__(self):
    method __enter__ (line 184) | def __enter__(self):
    method __exit__ (line 196) | def __exit__(self, exc_type, exc_val, exc_tb):
    method id_str (line 200) | def id_str(self):
    method create (line 203) | def create(self):
    method _set_id (line 226) | def _set_id(self, id):
    method _lock_refresh (line 233) | def _lock_refresh(self):
    method save_key (line 237) | def save_key(self, keydata):
    method load_key (line 241) | def load_key(self):
    method destroy (line 246) | def destroy(self):
    method open (line 251) | def open(self, *, exclusive, lock_wait=None, lock=True):
    method close (line 277) | def close(self):
    method info (line 286) | def info(self):
    method check (line 293) | def check(self, repair=False, max_duration=0):
    method list (line 425) | def list(self, limit=None, marker=None):
    method get (line 452) | def get(self, id, read_data=True, raise_missing=True):
    method get_many (line 484) | def get_many(self, ids, read_data=True, is_preloaded=False, raise_miss...
    method put (line 488) | def put(self, id, data, wait=True):
    method delete (line 502) | def delete(self, id, wait=True):
    method async_response (line 515) | def async_response(self, wait=True):
    method preload (line 526) | def preload(self, ids):
    method break_lock (line 529) | def break_lock(self):
    method migrate_lock (line 532) | def migrate_lock(self, old_id, new_id):
    method get_manifest (line 537) | def get_manifest(self):
    method put_manifest (line 544) | def put_manifest(self, data):
    method store_list (line 548) | def store_list(self, name, *, deleted=False):
    method store_load (line 555) | def store_load(self, name):
    method store_store (line 559) | def store_store(self, name, value):
    method store_delete (line 563) | def store_delete(self, name, *, deleted=False):
    method store_move (line 567) | def store_move(self, name, new_name=None, *, delete=False, undelete=Fa...

FILE: src/borg/selftest.py
  class SelfTestResult (line 32) | class SelfTestResult(TestResult):
    method __init__ (line 33) | def __init__(self):
    method addSuccess (line 37) | def addSuccess(self, test):
    method test_name (line 41) | def test_name(self, test):
    method log_results (line 44) | def log_results(self, logger):
    method successful_test_count (line 50) | def successful_test_count(self):
  function selftest (line 54) | def selftest(logger):

FILE: src/borg/storelocking.py
  class LockError (line 17) | class LockError(Error):
  class LockErrorT (line 23) | class LockErrorT(ErrorWithTraceback):
  class LockFailed (line 29) | class LockFailed(LockErrorT):
  class LockTimeout (line 35) | class LockTimeout(LockError):
  class NotLocked (line 41) | class NotLocked(LockErrorT):
  class NotMyLock (line 47) | class NotMyLock(LockErrorT):
  class Lock (line 53) | class Lock:
    method __init__ (line 70) | def __init__(self, store, exclusive=False, sleep=None, timeout=1.0, st...
    method __enter__ (line 86) | def __enter__(self):
    method __exit__ (line 89) | def __exit__(self, exc_type, exc_val, exc_tb):
    method __repr__ (line 95) | def __repr__(self):
    method _create_lock (line 98) | def _create_lock(self, *, exclusive=None, update_last_refresh=False):
    method _delete_lock (line 112) | def _delete_lock(self, key, *, ignore_not_found=False, update_last_ref...
    method _is_our_lock (line 123) | def _is_our_lock(self, lock):
    method _is_stale_lock (line 126) | def _is_stale_lock(self, lock):
    method _get_locks (line 136) | def _get_locks(self):
    method _find_locks (line 155) | def _find_locks(self, *, only_exclusive=False, only_mine=False):
    method acquire (line 166) | def acquire(self):
    method release (line 212) | def release(self, *, ignore_not_found=False):
    method got_exclusive_lock (line 226) | def got_exclusive_lock(self):
    method break_lock (line 230) | def break_lock(self):
    method migrate_lock (line 238) | def migrate_lock(self, old_id, new_id):
    method refresh (line 249) | def refresh(self):

FILE: src/borg/testsuite/__init__.py
  function same_ts_ns (line 51) | def same_ts_ns(ts_ns1, ts_ns2):
  function granularity_sleep (line 58) | def granularity_sleep(*, ctime_quirk=False):
  function unopened_tempfile (line 117) | def unopened_tempfile():
  function changedir (line 123) | def changedir(dir):
  function is_root (line 130) | def is_root():
  function are_symlinks_supported (line 139) | def are_symlinks_supported():
  function are_hardlinks_supported (line 151) | def are_hardlinks_supported():
  function are_fifos_supported (line 170) | def are_fifos_supported():
  function is_utime_fully_supported (line 185) | def is_utime_fully_supported():
  function is_birthtime_fully_supported (line 205) | def is_birthtime_fully_supported():
  function filter_xattrs (line 228) | def filter_xattrs(x):
  class BaseTestCase (line 238) | class BaseTestCase(unittest.TestCase):
  class FakeInputs (line 246) | class FakeInputs:
    method __init__ (line 249) | def __init__(self, inputs):
    method __call__ (line 252) | def __call__(self, prompt=None):

FILE: src/borg/testsuite/archive_test.py
  function stats (line 21) | def stats():
  function test_stats_basic (line 28) | def test_stats_basic(stats):
  function test_stats_progress_tty (line 36) | def test_stats_progress_tty(stats, monkeypatch, columns=80):
  function test_stats_progress_file (line 62) | def test_stats_progress_file(stats, monkeypatch):
  function test_stats_format (line 82) | def test_stats_format(stats):
  function test_stats_progress_json (line 106) | def test_stats_progress_json(stats):
  function test_timestamp_parsing (line 137) | def test_timestamp_parsing(monkeypatch, isoformat, expected):
  class MockCache (line 146) | class MockCache:
    class MockRepo (line 147) | class MockRepo:
      method async_response (line 148) | def async_response(self, wait=True):
    method __init__ (line 151) | def __init__(self):
    method add_chunk (line 155) | def add_chunk(self, id, meta, data, stats=None, wait=True, ro_type=None):
  function test_cache_chunk_buffer (line 161) | def test_cache_chunk_buffer():
  function test_partial_cache_chunk_buffer (line 177) | def test_partial_cache_chunk_buffer():
  function make_chunks (line 199) | def make_chunks(items):
  function _validator (line 203) | def _validator(value):
  function process (line 207) | def process(input):
  function test_extra_garbage_no_sync (line 220) | def test_extra_garbage_no_sync():
  function split (line 226) | def split(left, length):
  function test_correct_stream (line 234) | def test_correct_stream():
  function test_missing_chunk (line 241) | def test_missing_chunk():
  function test_corrupt_chunk (line 248) | def test_corrupt_chunk():
  function item_keys_serialized (line 256) | def item_keys_serialized():
  function test_invalid_msgpacked_item (line 271) | def test_invalid_msgpacked_item(packed, item_keys_serialized):
  function test_valid_msgpacked_items (line 291) | def test_valid_msgpacked_items(packed, item_keys_serialized):
  function test_key_length_msgpacked_items (line 295) | def test_key_length_msgpacked_items():
  function test_backup_io (line 302) | def test_backup_io():
  function test_backup_io_iter (line 308) | def test_backup_io_iter():
  function test_get_item_uid_gid (line 326) | def test_get_item_uid_gid():
  function test_reject_non_sanitized_item (line 426) | def test_reject_non_sanitized_item():

FILE: src/borg/testsuite/archiver/__init__.py
  function exec_cmd (line 47) | def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b"", bina...
  function cmd_fixture (line 107) | def cmd_fixture(request):
  function generate_archiver_tests (line 121) | def generate_archiver_tests(metafunc, kinds: str):
  function checkts (line 138) | def checkts(ts):
  function cmd (line 143) | def cmd(archiver, *args, **kw):
  function create_src_archive (line 163) | def create_src_archive(archiver, name, ts=None):
  function open_archive (line 170) | def open_archive(repo_path, name):
  function open_repository (line 179) | def open_repository(archiver):
  function create_regular_file (line 186) | def create_regular_file(input_path, name, size=0, contents=None):
  function create_test_files (line 197) | def create_test_files(input_path, create_hardlinks=True):
  function _extract_repository_id (line 259) | def _extract_repository_id(repo_path):
  function _set_repository_id (line 264) | def _set_repository_id(repo_path, id):
  function _extract_hardlinks_setup (line 270) | def _extract_hardlinks_setup(archiver):
  function _create_test_caches (line 287) | def _create_test_caches(archiver):
  function _assert_test_caches (line 300) | def _assert_test_caches(archiver):
  function _create_test_tagged (line 307) | def _create_test_tagged(archiver):
  function _assert_test_tagged (line 316) | def _assert_test_tagged(archiver):
  function _create_test_keep_tagged (line 322) | def _create_test_keep_tagged(archiver):
  function _assert_test_keep_tagged (line 338) | def _assert_test_keep_tagged(archiver):
  function assert_creates_file (line 349) | def assert_creates_file(path):
  function assert_dirs_equal (line 355) | def assert_dirs_equal(dir1, dir2, **kwargs):
  function assert_line_exists (line 360) | def assert_line_exists(lines, expected_regexpr):
  function assert_line_not_exists (line 364) | def assert_line_not_exists(lines, expected_regexpr):
  function _assert_dirs_equal_cmp (line 370) | def _assert_dirs_equal_cmp(diff, ignore_flags=False, ignore_xattrs=False...
  function read_only (line 420) | def read_only(path):
  function wait_for_mountstate (line 459) | def wait_for_mountstate(mountpoint, *, mounted, timeout=5):
  function fuse_mount (line 471) | def fuse_mount(archiver, mountpoint=None, *options, fork=True, os_fork=F...

FILE: src/borg/testsuite/archiver/analyze_cmd_test.py
  function test_analyze (line 9) | def test_analyze(archivers, request):

FILE: src/borg/testsuite/archiver/argparsing_test.py
  function test_bad_filters (line 7) | def test_bad_filters(archiver):
  function test_highlander (line 13) | def test_highlander(archiver):
  function test_get_args (line 29) | def test_get_args():
  class TestCommonOptions (line 78) | class TestCommonOptions:
    method define_common_options (line 80) | def define_common_options(add_common_option):
    method basic_parser (line 95) | def basic_parser(self):
    method subcommands (line 101) | def subcommands(self, basic_parser):
    method parser (line 105) | def parser(self, basic_parser):
    method common_parser (line 110) | def common_parser(self, parser):
    method parse_vars_from_line (line 116) | def parse_vars_from_line(self, parser, subcommands, common_parser):
    method test_simple (line 129) | def test_simple(self, parse_vars_from_line):
    method test_flag_position_independence (line 160) | def test_flag_position_independence(self, parse_vars_from_line, positi...

FILE: src/borg/testsuite/archiver/benchmark_cmd_test.py
  function test_benchmark_crud (line 7) | def test_benchmark_crud(archiver, monkeypatch):
  function test_benchmark_crud_json_lines (line 17) | def test_benchmark_crud_json_lines(archiver, monkeypatch):
  function test_benchmark_cpu (line 48) | def test_benchmark_cpu(archiver, monkeypatch):
  function test_benchmark_cpu_json (line 61) | def test_benchmark_cpu_json(archiver, monkeypatch):

FILE: src/borg/testsuite/archiver/check_cmd_test.py
  function check_cmd_setup (line 20) | def check_cmd_setup(archiver):
  function test_check_usage (line 27) | def test_check_usage(archivers, request):
  function test_date_matching (line 55) | def test_date_matching(archivers, request):
  function test_missing_file_chunk (line 142) | def test_missing_file_chunk(archivers, request):
  function test_missing_archive_item_chunk (line 184) | def test_missing_archive_item_chunk(archivers, request):
  function test_missing_archive_metadata (line 195) | def test_missing_archive_metadata(archivers, request):
  function test_missing_manifest (line 206) | def test_missing_manifest(archivers, request):
  function test_corrupted_manifest (line 222) | def test_corrupted_manifest(archivers, request):
  function test_spoofed_manifest (line 237) | def test_spoofed_manifest(archivers, request):
  function test_manifest_rebuild_corrupted_chunk (line 270) | def test_manifest_rebuild_corrupted_chunk(archivers, request):
  function test_check_undelete_archives (line 287) | def test_check_undelete_archives(archivers, request):
  function test_spoofed_archive (line 307) | def test_spoofed_archive(archivers, request):
  function test_extra_chunks (line 347) | def test_extra_chunks(archivers, request):
  function test_verify_data (line 360) | def test_verify_data(archivers, request, init_args):
  function test_corrupted_file_chunk (line 412) | def test_corrupted_file_chunk(archivers, request, init_args):
  function test_empty_repository (line 445) | def test_empty_repository(archivers, request):

FILE: src/borg/testsuite/archiver/checks_test.py
  function get_security_directory (line 22) | def get_security_directory(repo_path):
  function add_unknown_feature (line 27) | def add_unknown_feature(repo_path, operation):
  function cmd_raises_unknown_feature (line 34) | def cmd_raises_unknown_feature(archiver, args):
  function test_repository_swap_detection (line 43) | def test_repository_swap_detection(archivers, request):
  function test_repository_swap_detection2 (line 61) | def test_repository_swap_detection2(archivers, request):
  function test_repository_swap_detection_no_cache (line 80) | def test_repository_swap_detection_no_cache(archivers, request):
  function test_repository_swap_detection2_no_cache (line 99) | def test_repository_swap_detection2_no_cache(archivers, request):
  function test_repository_swap_detection_repokey_blank_passphrase (line 122) | def test_repository_swap_detection_repokey_blank_passphrase(archivers, r...
  function test_repository_move (line 149) | def test_repository_move(archivers, request, monkeypatch):
  function test_unknown_unencrypted (line 178) | def test_unknown_unencrypted(archivers, request, monkeypatch):
  function test_unknown_feature_on_create (line 199) | def test_unknown_feature_on_create(archivers, request):
  function test_unknown_feature_on_change_passphrase (line 206) | def test_unknown_feature_on_change_passphrase(archivers, request):
  function test_unknown_feature_on_read (line 213) | def test_unknown_feature_on_read(archivers, request):
  function test_unknown_feature_on_rename (line 224) | def test_unknown_feature_on_rename(archivers, request):
  function test_unknown_feature_on_delete (line 232) | def test_unknown_feature_on_delete(archivers, request):
  function test_unknown_feature_on_mount (line 245) | def test_unknown_feature_on_mount(archivers, request):
  function test_unknown_mandatory_feature_in_cache (line 256) | def test_unknown_mandatory_feature_in_cache(archivers, request):
  function test_remote_repo_restrict_to_path (line 280) | def test_remote_repo_restrict_to_path(remote_archiver):
  function test_remote_repo_restrict_to_repository (line 308) | def test_remote_repo_restrict_to_repository(remote_archiver):
  function test_remote_repo_strip_components_doesnt_leak (line 319) | def test_remote_repo_strip_components_doesnt_leak(remote_archiver):

FILE: src/borg/testsuite/archiver/compact_cmd_test.py
  function test_compact_empty_repository (line 14) | def test_compact_empty_repository(archivers, request, stats):
  function test_compact_after_deleting_all_archives (line 30) | def test_compact_after_deleting_all_archives(archivers, request, stats):
  function test_compact_after_deleting_some_archives (line 49) | def test_compact_after_deleting_some_archives(archivers, request, stats):
  function test_compact_index_corruption (line 68) | def test_compact_index_corruption(archivers, request):
  function test_compact_files_cache_cleanup (line 88) | def test_compact_files_cache_cleanup(archivers, request):

FILE: src/borg/testsuite/archiver/completion_cmd_test.py
  function cmd_available (line 14) | def cmd_available(cmd):
  function _run_bash_completion_fn (line 27) | def _run_bash_completion_fn(completion_script, setup_code):
  function test_bash_completion_nontrivial (line 44) | def test_bash_completion_nontrivial(archivers, request):
  function test_zsh_completion_nontrivial (line 52) | def test_zsh_completion_nontrivial(archivers, request):
  function _check_shell_syntax (line 63) | def _check_shell_syntax(script_content, shell, suffix):
  function test_bash_completion_syntax (line 76) | def test_bash_completion_syntax(archivers, request):
  function test_zsh_completion_syntax (line 85) | def test_zsh_completion_syntax(archivers, request):
  function test_bash_sortby_dedup (line 97) | def test_bash_sortby_dedup(archivers, request):
  function test_bash_filescachemode_exclusivity (line 117) | def test_bash_filescachemode_exclusivity(archivers, request):
  function test_bash_archive_name_completion (line 149) | def test_bash_archive_name_completion(archivers, request):
  function test_bash_archive_aid_completion (line 168) | def test_bash_archive_aid_completion(archivers, request):

FILE: src/borg/testsuite/archiver/corruption_test.py
  function corrupt_archiver (line 12) | def corrupt_archiver(archiver):
  function test_old_version_interfered (line 18) | def test_old_version_interfered(archiver):

FILE: src/borg/testsuite/archiver/create_cmd_test.py
  function test_basic_functionality (line 51) | def test_basic_functionality(archivers, request):
  function test_archived_paths (line 125) | def test_archived_paths(archivers, request):
  function test_create_msys2_path_translation_warning (line 155) | def test_create_msys2_path_translation_warning(archivers, request, monke...
  function test_create_duplicate_root (line 194) | def test_create_duplicate_root(archivers, request):
  function test_create_unreadable_parent (line 214) | def test_create_unreadable_parent(archiver):
  function test_unix_socket (line 229) | def test_unix_socket(archivers, request, monkeypatch):
  function test_nobirthtime (line 251) | def test_nobirthtime(archivers, request):
  function test_create_stdin (line 269) | def test_create_stdin(archivers, request):
  function test_create_erroneous_file (line 281) | def test_create_erroneous_file(archivers, request):
  function test_create_no_permission_file (line 311) | def test_create_no_permission_file(archivers, request):
  function test_sanitized_stdin_name (line 348) | def test_sanitized_stdin_name(archivers, request):
  function test_dotdot_stdin_name (line 356) | def test_dotdot_stdin_name(archivers, request):
  function test_dot_stdin_name (line 363) | def test_dot_stdin_name(archivers, request):
  function test_create_content_from_command (line 370) | def test_create_content_from_command(archivers, request):
  function test_create_content_from_command_with_failed_command (line 383) | def test_create_content_from_command_with_failed_command(archivers, requ...
  function test_create_content_from_command_missing_command (line 399) | def test_create_content_from_command_missing_command(archivers, request):
  function test_create_paths_from_stdin (line 406) | def test_create_paths_from_stdin(archivers, request):
  function test_create_paths_from_command (line 420) | def test_create_paths_from_command(archivers, request):
  function test_create_paths_from_command_with_failed_command (line 438) | def test_create_paths_from_command_with_failed_command(archivers, request):
  function test_create_paths_from_command_missing_command (line 454) | def test_create_paths_from_command_missing_command(archivers, request):
  function test_create_paths_from_shell_command (line 462) | def test_create_paths_from_shell_command(archivers, request):
  function test_create_without_root (line 476) | def test_create_without_root(archivers, request):
  function test_create_pattern_root (line 483) | def test_create_pattern_root(archivers, request):
  function test_create_pattern (line 494) | def test_create_pattern(archivers, request):
  function test_create_pattern_file (line 509) | def test_create_pattern_file(archivers, request):
  function test_create_pattern_exclude_folder_but_recurse (line 533) | def test_create_pattern_exclude_folder_but_recurse(archivers, request):
  function test_create_pattern_exclude_folder_no_recurse (line 549) | def test_create_pattern_exclude_folder_no_recurse(archivers, request):
  function test_create_pattern_intermediate_folders_first (line 565) | def test_create_pattern_intermediate_folders_first(archivers, request):
  function test_create_archivename_with_placeholder (line 586) | def test_create_archivename_with_placeholder(archivers, request):
  function test_exclude_caches (line 598) | def test_exclude_caches(archivers, request):
  function test_exclude_tagged (line 605) | def test_exclude_tagged(archivers, request):
  function test_exclude_keep_tagged (line 612) | def test_exclude_keep_tagged(archivers, request):
  function test_path_sanitation (line 630) | def test_path_sanitation(archivers, request):
  function test_exclude_sanitation (line 641) | def test_exclude_sanitation(archivers, request):
  function test_repeated_files (line 662) | def test_repeated_files(archivers, request):
  function test_umask (line 671) | def test_umask(archivers, request):
  function test_create_dry_run (line 680) | def test_create_dry_run(archivers, request):
  function test_progress_on (line 690) | def test_progress_on(archivers, request):
  function test_progress_off (line 698) | def test_progress_off(archivers, request):
  function test_file_status (line 706) | def test_file_status(archivers, request):
  function test_create_tags (line 725) | def test_create_tags(archivers, request):
  function test_create_invalid_tags (line 735) | def test_create_invalid_tags(archivers, request):
  function test_file_status_cs_cache_mode (line 746) | def test_file_status_cs_cache_mode(archivers, request):
  function test_files_changed_modes (line 763) | def test_files_changed_modes(archivers, request):
  function test_file_status_ms_cache_mode (line 777) | def test_file_status_ms_cache_mode(archivers, request):
  function test_file_status_rc_cache_mode (line 793) | def test_file_status_rc_cache_mode(archivers, request):
  function test_file_status_excluded (line 806) | def test_file_status_excluded(archivers, request):
  function test_file_status_counters (line 829) | def test_file_status_counters(archivers, request):
  function test_create_json (line 871) | def test_create_json(archivers, request):
  function test_explicit_hostname_and_username (line 890) | def test_explicit_hostname_and_username(archivers, request):
  function test_create_topical (line 901) | def test_create_topical(archivers, request):
  function test_create_read_special_symlink (line 928) | def test_create_read_special_symlink(archivers, request):
  function test_create_read_special_broken_symlink (line 971) | def test_create_read_special_broken_symlink(archivers, request):
  function test_create_dotslash_hack (line 980) | def test_create_dotslash_hack(archivers, request):
  function test_log_json (line 1006) | def test_log_json(archivers, request):
  function test_common_options (line 1026) | def test_common_options(archivers, request):
  function test_create_big_zeros_files (line 1034) | def test_create_big_zeros_files(archivers, request):
  function test_create_big_random_files (line 1064) | def test_create_big_random_files(archivers, request):
  function test_create_with_compression_algorithms (line 1096) | def test_create_with_compression_algorithms(archivers, request):
  function test_exclude_nodump_dir_with_file (line 1158) | def test_exclude_nodump_dir_with_file(archivers, request):

FILE: src/borg/testsuite/archiver/debug_cmds_test.py
  function test_debug_profile (line 13) | def test_debug_profile(archivers, request):
  function test_debug_dump_archive_items (line 28) | def test_debug_dump_archive_items(archivers, request):
  function test_debug_dump_repo_objs (line 40) | def test_debug_dump_repo_objs(archivers, request):
  function test_debug_put_get_delete_obj (line 52) | def test_debug_put_get_delete_obj(archivers, request):
  function test_debug_id_hash_format_put_get_parse_obj (line 81) | def test_debug_id_hash_format_put_get_parse_obj(archivers, request):
  function test_debug_format_obj_respects_type (line 126) | def test_debug_format_obj_respects_type(archivers, request):
  function test_debug_dump_manifest (line 148) | def test_debug_dump_manifest(archivers, request):
  function test_debug_dump_archive (line 166) | def test_debug_dump_archive(archivers, request):
  function test_debug_info (line 183) | def test_debug_info(archivers, request):

FILE: src/borg/testsuite/archiver/delete_cmd_test.py
  function test_delete_options (line 7) | def test_delete_options(archivers, request):
  function test_delete_multiple (line 26) | def test_delete_multiple(archivers, request):
  function test_delete_ignore_protected (line 37) | def test_delete_ignore_protected(archivers, request):

FILE: src/borg/testsuite/archiver/diff_cmd_test.py
  function test_basic_functionality (line 23) | def test_basic_functionality(archivers, request):
  function test_time_diffs (line 266) | def test_time_diffs(archivers, request):
  function test_sort_by_option (line 292) | def test_sort_by_option(archivers, request):
  function test_sort_by_invalid_field_is_rejected (line 320) | def test_sort_by_invalid_field_is_rejected(archivers, request):
  function test_sort_by_size_added_then_path (line 333) | def test_sort_by_size_added_then_path(archivers, request):
  function test_sort_by_all_keys_with_directions (line 382) | def test_sort_by_all_keys_with_directions(archivers, request, sort_key):
  function test_hard_link_deletion_and_replacement (line 434) | def test_hard_link_deletion_and_replacement(archivers, request):

FILE: src/borg/testsuite/archiver/disk_full_test.py
  function make_files (line 31) | def make_files(dir, count, size, rnd=True):
  function test_disk_full (line 47) | def test_disk_full(test_pass, cmd_fixture, monkeypatch):

FILE: src/borg/testsuite/archiver/extract_cmd_test.py
  function test_symlink_extract (line 39) | def test_symlink_extract(archivers, request):
  function test_hardlinked_symlinks_extract (line 53) | def test_hardlinked_symlinks_extract(archivers, request):
  function test_directory_timestamps1 (line 77) | def test_directory_timestamps1(archivers, request):
  function test_directory_timestamps2 (line 94) | def test_directory_timestamps2(archivers, request):
  function test_directory_timestamps3 (line 112) | def test_directory_timestamps3(archivers, request):
  function test_atime (line 130) | def test_atime(archivers, request):
  function test_birthtime (line 167) | def test_birthtime(archivers, request):
  function test_sparse_file (line 185) | def test_sparse_file(archivers, request):
  function test_unusual_filenames (line 241) | def test_unusual_filenames(archivers, request):
  function test_strip_components (line 256) | def test_strip_components(archivers, request):
  function test_extract_hardlinks1 (line 273) | def test_extract_hardlinks1(archivers, request):
  function test_extract_hardlinks2 (line 286) | def test_extract_hardlinks2(archivers, request):
  function test_extract_hardlinks_twice (line 308) | def test_extract_hardlinks_twice(archivers, request):
  function test_extract_include_exclude (line 332) | def test_extract_include_exclude(archivers, request):
  function test_extract_include_exclude_regex (line 354) | def test_extract_include_exclude_regex(archivers, request):
  function test_extract_include_exclude_regex_from_file (line 395) | def test_extract_include_exclude_regex_from_file(archivers, request):
  function test_extract_with_pattern (line 435) | def test_extract_with_pattern(archivers, request):
  function test_extract_list_output (line 469) | def test_extract_list_output(archivers, request):
  function test_extract_progress (line 495) | def test_extract_progress(archivers, request):
  function test_extract_pattern_opt (line 506) | def test_extract_pattern_opt(archivers, request):
  function test_extract_capabilities (line 519) | def test_extract_capabilities(archivers, request):
  function test_extract_xattrs_errors (line 544) | def test_extract_xattrs_errors(archivers, request):
  function test_extract_xattrs_resourcefork (line 585) | def test_extract_xattrs_resourcefork(archivers, request):
  function test_extract_restores_append_flag (line 611) | def test_extract_restores_append_flag(archivers, request):
  function test_overwrite (line 637) | def test_overwrite(archivers, request):
  function test_do_not_fail_when_percent_is_in_xattr_name (line 667) | def test_do_not_fail_when_percent_is_in_xattr_name(archivers, request):
  function test_do_not_fail_when_percent_is_in_file_name (line 687) | def test_do_not_fail_when_percent_is_in_file_name(archivers, request):
  function test_extract_continue (line 706) | def test_extract_continue(archivers, request):
  function test_dry_run_extraction_flags (line 774) | def test_dry_run_extraction_flags(archivers, request):
  function test_extract_file_with_missing_chunk (line 793) | def test_extract_file_with_missing_chunk(archivers, request):
  function test_extract_existing_directory (line 812) | def test_extract_existing_directory(archivers, request):
  function test_extract_y2261 (line 830) | def test_extract_y2261(archivers, request):

FILE: src/borg/testsuite/archiver/help_cmd_test.py
  function get_all_parsers (line 8) | def get_all_parsers():
  function test_usage (line 33) | def test_usage(archiver):
  function test_help (line 38) | def test_help(archiver):
  function test_help_formatting (line 47) | def test_help_formatting(command, parser):
  function test_help_formatting_helptexts (line 53) | def test_help_formatting_helptexts(topic):

FILE: src/borg/testsuite/archiver/info_cmd_test.py
  function test_info (line 11) | def test_info(archivers, request):
  function test_info_json (line 22) | def test_info_json(archivers, request):
  function test_info_json_of_empty_archive (line 42) | def test_info_json_of_empty_archive(archivers, request):
  function test_info_working_directory (line 52) | def test_info_working_directory(archivers, request):

FILE: src/borg/testsuite/archiver/key_cmds_test.py
  function test_change_passphrase (line 19) | def test_change_passphrase(archivers, request):
  function test_change_location_to_keyfile (line 29) | def test_change_location_to_keyfile(archivers, request):
  function test_change_location_to_b2keyfile (line 39) | def test_change_location_to_b2keyfile(archivers, request):
  function test_change_location_to_repokey (line 49) | def test_change_location_to_repokey(archivers, request):
  function test_change_location_to_b2repokey (line 59) | def test_change_location_to_b2repokey(archivers, request):
  function test_key_export_keyfile (line 69) | def test_key_export_keyfile(archivers, request):
  function test_key_import_keyfile_with_borg_key_file (line 98) | def test_key_import_keyfile_with_borg_key_file(archivers, request, monke...
  function test_key_export_repokey (line 120) | def test_key_export_repokey(archivers, request):
  function test_key_export_qr (line 153) | def test_key_export_qr(archivers, request):
  function test_key_export_directory (line 168) | def test_key_export_directory(archivers, request):
  function test_key_export_qr_directory (line 181) | def test_key_export_qr_directory(archivers, request):
  function test_key_import_errors (line 194) | def test_key_import_errors(archivers, request):
  function test_key_export_paperkey (line 226) | def test_key_export_paperkey(archivers, request):
  function test_key_import_paperkey (line 255) | def test_key_import_paperkey(archivers, request):
  function test_init_defaults_to_argon2 (line 301) | def test_init_defaults_to_argon2(archivers, request):
  function test_change_passphrase_does_not_change_algorithm_argon2 (line 310) | def test_change_passphrase_does_not_change_algorithm_argon2(archivers, r...
  function test_change_location_does_not_change_algorithm_argon2 (line 321) | def test_change_location_does_not_change_algorithm_argon2(archivers, req...

FILE: src/borg/testsuite/archiver/list_cmd_test.py
  function test_list_format (line 11) | def test_list_format(archivers, request, backup_files):
  function test_list_hash (line 24) | def test_list_hash(archivers, request):
  function test_list_chunk_counts (line 35) | def test_list_chunk_counts(archivers, request):
  function test_list_size (line 51) | def test_list_size(archivers, request):
  function test_list_json (line 61) | def test_list_json(archivers, request):
  function test_list_json_lines_includes_archive_keys_in_format (line 82) | def test_list_json_lines_includes_archive_keys_in_format(archivers, requ...
  function test_list_depth (line 105) | def test_list_depth(archivers, request):
  function test_list_inode_hardlinks (line 167) | def test_list_inode_hardlinks(archivers, request):
  function test_fingerprint (line 206) | def test_fingerprint(archivers, request):

FILE: src/borg/testsuite/archiver/lock_cmds_test.py
  function test_break_lock (line 16) | def test_break_lock(archivers, request):
  function test_with_lock (line 23) | def test_with_lock(tmp_path):
  function test_with_lock_non_existent_command (line 57) | def test_with_lock_non_existent_command(archivers, request):

FILE: src/borg/testsuite/archiver/mount_cmds_test.py
  function test_fuse_mount_hardlinks (line 30) | def test_fuse_mount_hardlinks(archivers, request):
  function test_fuse (line 68) | def test_fuse(archivers, request):
  function test_fuse_versions_view (line 176) | def test_fuse_versions_view(archivers, request):
  function test_fuse_duplicate_name (line 210) | def test_fuse_duplicate_name(archivers, request):
  function test_fuse_allow_damaged_files (line 228) | def test_fuse_allow_damaged_files(archivers, request):
  function test_fuse_mount_options (line 258) | def test_fuse_mount_options(archivers, request):
  function test_migrate_lock_alive (line 281) | def test_migrate_lock_alive(archivers, request):

FILE: src/borg/testsuite/archiver/patterns_test.py
  function test_basic (line 7) | def test_basic():
  function test_empty (line 16) | def test_empty():
  function test_strip_components (line 22) | def test_strip_components():

FILE: src/borg/testsuite/archiver/prune_cmd_test.py
  function _create_archive_ts (line 14) | def _create_archive_ts(archiver, backup_files, name, y, m, d, H=0, M=0, ...
  function test_prune_repository (line 25) | def test_prune_repository(archivers, request, backup_files):
  function test_prune_repository_example (line 45) | def test_prune_repository_example(archivers, request, backup_files):
  function test_prune_quarterly (line 107) | def test_prune_quarterly(archivers, request, backup_files):
  function test_prune_retain_and_expire_oldest (line 179) | def test_prune_retain_and_expire_oldest(archivers, request, backup_files):
  function test_prune_repository_prefix (line 204) | def test_prune_repository_prefix(archivers, request, backup_files):
  function test_prune_repository_glob (line 227) | def test_prune_repository_glob(archivers, request, backup_files):
  function test_prune_ignore_protected (line 250) | def test_prune_ignore_protected(archivers, request):
  class MockArchive (line 266) | class MockArchive:
    method __init__ (line 267) | def __init__(self, ts, id):
    method __repr__ (line 271) | def __repr__(self):
  function test_prune_within (line 286) | def test_prune_within():
  function test_prune_split (line 331) | def test_prune_split(rule, num_to_keep, expected_ids):
  function test_prune_split_keep_oldest (line 363) | def test_prune_split_keep_oldest():
  function test_prune_split_no_archives (line 395) | def test_prune_split_no_archives():
  function test_prune_list_with_metadata_format (line 405) | def test_prune_list_with_metadata_format(archivers, request, backup_files):

FILE: src/borg/testsuite/archiver/recreate_cmd_test.py
  function test_recreate_exclude_caches (line 28) | def test_recreate_exclude_caches(archivers, request):
  function test_recreate_exclude_tagged (line 36) | def test_recreate_exclude_tagged(archivers, request):
  function test_recreate_exclude_keep_tagged (line 44) | def test_recreate_exclude_keep_tagged(archivers, request):
  function test_recreate_hardlinked_tags (line 64) | def test_recreate_hardlinked_tags(archivers, request):  # test for issue...
  function test_recreate_target (line 82) | def test_recreate_target(archivers, request):
  function test_recreate_basic (line 103) | def test_recreate_basic(archivers, request):
  function test_recreate_subtree_hardlinks (line 118) | def test_recreate_subtree_hardlinks(archivers, request):
  function test_recreate_rechunkify (line 136) | def test_recreate_rechunkify(archivers, request):
  function test_recreate_fixed_rechunkify (line 158) | def test_recreate_fixed_rechunkify(archivers, request):
  function test_recreate_no_rechunkify (line 173) | def test_recreate_no_rechunkify(archivers, request):
  function test_recreate_keep_original_timestamp (line 190) | def test_recreate_keep_original_timestamp(archivers, request):
  function test_recreate_with_given_timestamp (line 205) | def test_recreate_with_given_timestamp(archivers, request):
  function test_recreate_dry_run (line 223) | def test_recreate_dry_run(archivers, request):
  function test_recreate_skips_nothing_to_do (line 235) | def test_recreate_skips_nothing_to_do(archivers, request):
  function test_recreate_list_output (line 247) | def test_recreate_list_output(archivers, request):
  function test_comment (line 278) | def test_comment(archivers, request):
  function test_recreate_ignore_protected (line 300) | def test_recreate_ignore_protected(archivers, request):

FILE: src/borg/testsuite/archiver/remote_repo_test.py
  function have_rclone (line 16) | def have_rclone():
  function test_rclone_repo_basics (line 35) | def test_rclone_repo_basics(archiver, tmp_path):
  function test_sftp_repo_basics (line 61) | def test_sftp_repo_basics(archiver):
  function test_s3_repo_basics (line 85) | def test_s3_repo_basics(archiver):

FILE: src/borg/testsuite/archiver/rename_cmd_test.py
  function test_rename (line 9) | def test_rename(archivers, request):

FILE: src/borg/testsuite/archiver/repo_compress_cmd_test.py
  function test_repo_compress (line 12) | def test_repo_compress(archiver):
  function test_repo_compress_stats (line 74) | def test_repo_compress_stats(archiver):

FILE: src/borg/testsuite/archiver/repo_create_cmd_test.py
  function test_repo_create_interrupt (line 14) | def test_repo_create_interrupt(archivers, request):
  function test_repo_create_requires_encryption_option (line 32) | def test_repo_create_requires_encryption_option(archivers, request):
  function test_repo_create_refuse_to_overwrite_keyfile (line 37) | def test_repo_create_refuse_to_overwrite_keyfile(archivers, request, mon...
  function test_repo_create_keyfile_same_path_creates_new_keys (line 60) | def test_repo_create_keyfile_same_path_creates_new_keys(archivers, reque...

FILE: src/borg/testsuite/archiver/repo_delete_cmd_test.py
  function test_delete_repo (line 12) | def test_delete_repo(archivers, request):

FILE: src/borg/testsuite/archiver/repo_info_cmd_test.py
  function test_info (line 9) | def test_info(archivers, request):
  function test_info_json (line 18) | def test_info_json(archivers, request):

FILE: src/borg/testsuite/archiver/repo_list_cmd_test.py
  function test_repo_list_glob (line 11) | def test_repo_list_glob(archivers, request, backup_files):
  function test_archives_format (line 23) | def test_archives_format(archivers, request, backup_files):
  function test_size_nfiles (line 43) | def test_size_nfiles(archivers, request):
  function test_date_matching (line 58) | def test_date_matching(archivers, request, backup_files):
  function test_repo_list_json (line 139) | def test_repo_list_json(archivers, request):
  function test_repo_list_deleted (line 154) | def test_repo_list_deleted(archivers, request, backup_files):

FILE: src/borg/testsuite/archiver/repo_space_cmd_test.py
  function test_repo_space_basics (line 8) | def test_repo_space_basics(archivers, request):
  function test_repo_space_modify_reservation (line 35) | def test_repo_space_modify_reservation(archivers, request):
  function test_repo_space_edge_cases (line 60) | def test_repo_space_edge_cases(archivers, request):

FILE: src/borg/testsuite/archiver/restricted_permissions_test.py
  function test_repository_permissions_all (line 13) | def test_repository_permissions_all(archivers, request, monkeypatch):
  function test_repository_permissions_no_delete (line 37) | def test_repository_permissions_no_delete(archivers, request, monkeypatch):
  function test_repository_permissions_read_only (line 95) | def test_repository_permissions_read_only(archivers, request, monkeypatch):
  function test_repository_permissions_write_only (line 141) | def test_repository_permissions_write_only(archivers, request, monkeypat...

FILE: src/borg/testsuite/archiver/return_codes_test.py
  function test_return_codes (line 11) | def test_return_codes(archivers, request):
  function test_exit_codes (line 27) | def test_exit_codes(archivers, request, monkeypatch):

FILE: src/borg/testsuite/archiver/serve_cmd_test.py
  function have_a_short_runtime_dir (line 14) | def have_a_short_runtime_dir(mp):
  function serve_socket (line 22) | def serve_socket(monkeypatch):
  function test_with_socket (line 34) | def test_with_socket(serve_socket, tmpdir, monkeypatch):
  function test_socket_permissions (line 53) | def test_socket_permissions(serve_socket):

FILE: src/borg/testsuite/archiver/tag_cmd_test.py
  function test_tag_set (line 7) | def test_tag_set(archivers, request):
  function test_tag_add_remove (line 21) | def test_tag_add_remove(archivers, request):
  function test_tag_set_noclobber_special (line 35) | def test_tag_set_noclobber_special(archivers, request):
  function test_tag_only_known_special (line 50) | def test_tag_only_known_special(archivers, request):

FILE: src/borg/testsuite/archiver/tar_cmds_test.py
  function have_gnutar (line 19) | def have_gnutar():
  function test_export_tar (line 32) | def test_export_tar(archivers, request):
  function test_export_tar_gz (line 47) | def test_export_tar_gz(archivers, request):
  function test_export_tar_strip_components (line 63) | def test_export_tar_strip_components(archivers, request):
  function test_export_tar_strip_components_links (line 80) | def test_export_tar_strip_components_links(archivers, request):
  function test_extract_hardlinks_tar (line 94) | def test_extract_hardlinks_tar(archivers, request):
  function test_import_tar (line 106) | def test_import_tar(archivers, request, tar_format="PAX"):
  function test_import_unusual_tar (line 119) | def test_import_unusual_tar(archivers, request):
  function test_import_tar_with_dotdot (line 135) | def test_import_tar_with_dotdot(archivers, request):
  function test_import_tar_gz (line 149) | def test_import_tar_gz(archivers, request, tar_format="GNU"):
  function test_import_concatenated_tar_with_ignore_zeros (line 163) | def test_import_concatenated_tar_with_ignore_zeros(archivers, request):
  function test_import_concatenated_tar_without_ignore_zeros (line 192) | def test_import_concatenated_tar_without_ignore_zeros(archivers, request):
  function test_import_tar_with_dotslash_paths (line 217) | def test_import_tar_with_dotslash_paths(archivers, request):
  function test_roundtrip_pax_borg (line 244) | def test_roundtrip_pax_borg(archivers, request):
  function test_roundtrip_pax_xattrs (line 257) | def test_roundtrip_pax_xattrs(archivers, request):
  function test_acl_roundtrip (line 278) | def test_acl_roundtrip(archivers, request):

FILE: src/borg/testsuite/archiver/transfer_cmd_test.py
  function test_transfer_upgrade (line 23) | def test_transfer_upgrade(archivers, request, monkeypatch):
  function setup_repos (line 288) | def setup_repos(archiver, mp):
  function test_transfer (line 312) | def test_transfer(archivers, request, monkeypatch):
  function test_transfer_archive_metadata (line 338) | def test_transfer_archive_metadata(archivers, request, monkeypatch):
  function test_transfer_recompress (line 381) | def test_transfer_recompress(archivers, request, monkeypatch, recompress...
  function test_transfer_rechunk (line 416) | def test_transfer_rechunk(archivers, request, monkeypatch):
  function test_transfer_rechunk_dry_run (line 479) | def test_transfer_rechunk_dry_run(archivers, request, monkeypatch):
  function test_issue_9022 (line 506) | def test_issue_9022(archivers, request, monkeypatch):

FILE: src/borg/testsuite/archiver/undelete_cmd_test.py
  function test_undelete_single (line 7) | def test_undelete_single(archivers, request):
  function test_undelete_multiple_dryrun (line 24) | def test_undelete_multiple_dryrun(archivers, request):
  function test_undelete_multiple_run (line 47) | def test_undelete_multiple_run(archivers, request):

FILE: src/borg/testsuite/benchmark_test.py
  function repo_url (line 19) | def repo_url(request, tmpdir, monkeypatch):
  function repo (line 31) | def repo(request, cmd_fixture, repo_url):
  function testdata (line 37) | def testdata(request, tmpdir_factory):
  function repo_archive (line 62) | def repo_archive(request, cmd_fixture, repo, testdata):
  function test_create_none (line 68) | def test_create_none(benchmark, cmd_fixture, repo, testdata):
  function test_create_lz4 (line 75) | def test_create_lz4(benchmark, cmd_fixture, repo, testdata):
  function test_extract (line 82) | def test_extract(benchmark, cmd_fixture, repo_archive, tmpdir):
  function test_delete (line 89) | def test_delete(benchmark, cmd_fixture, repo_archive):
  function test_list (line 95) | def test_list(benchmark, cmd_fixture, repo_archive):
  function test_info (line 101) | def test_info(benchmark, cmd_fixture, repo_archive):
  function test_check (line 107) | def test_check(benchmark, cmd_fixture, repo_archive):
  function test_help (line 113) | def test_help(benchmark, cmd_fixture):
  function test_propdict_attributes (line 119) | def test_propdict_attributes(benchmark, type, key, value):

FILE: src/borg/testsuite/cache_test.py
  class TestAdHocWithFilesCache (line 14) | class TestAdHocWithFilesCache:
    method repository (line 16) | def repository(self, tmpdir):
    method key (line 23) | def key(self, repository, monkeypatch):
    method manifest (line 29) | def manifest(self, repository, key):
    method cache (line 34) | def cache(self, repository, key, manifest):
    method test_does_not_contain_manifest (line 37) | def test_does_not_contain_manifest(self, cache):
    method test_seen_chunk_add_chunk_size (line 40) | def test_seen_chunk_add_chunk_size(self, cache):
    method test_reuse_after_add_chunk (line 43) | def test_reuse_after_add_chunk(self, cache):
    method test_existing_reuse_after_add_chunk (line 47) | def test_existing_reuse_after_add_chunk(self, cache):
    method test_files_cache (line 51) | def test_files_cache(self, cache):
  function test_delete_chunkindex_cache_missing (line 58) | def test_delete_chunkindex_cache_missing(tmp_path):
  function test_read_chunkindex_from_repo_cache_missing (line 78) | def test_read_chunkindex_from_repo_cache_missing(tmp_path):

FILE: src/borg/testsuite/checksums_test.py
  function test_xxh64 (line 6) | def test_xxh64():

FILE: src/borg/testsuite/chunkers/__init__.py
  function cf (line 9) | def cf(chunks):
  function cf_expand (line 25) | def cf_expand(chunks):
  function make_sparsefile (line 30) | def make_sparsefile(fname, sparsemap, header_size=0):
  function make_content (line 46) | def make_content(sparsemap, header_size=0):
  function fs_supports_sparse (line 61) | def fs_supports_sparse():

FILE: src/borg/testsuite/chunkers/buzhash64_self_test.py
  class ChunkerBuzHash64TestCase (line 19) | class ChunkerBuzHash64TestCase(BaseTestCase):
    method test_chunkify64 (line 20) | def test_chunkify64(self):
    method test_buzhash64 (line 63) | def test_buzhash64(self):
    method test_small_reads64 (line 73) | def test_small_reads64(self):

FILE: src/borg/testsuite/chunkers/buzhash64_test.py
  function H (line 20) | def H(data):
  function test_chunkpoints64_unchanged (line 24) | def test_chunkpoints64_unchanged():
  function test_buzhash64_chunksize_distribution (line 55) | def test_buzhash64_chunksize_distribution():
  function test_buzhash64_table (line 82) | def test_buzhash64_table():
  function test_fuzz_bh64 (line 108) | def test_fuzz_bh64(worker):

FILE: src/borg/testsuite/chunkers/buzhash_self_test.py
  class ChunkerTestCase (line 13) | class ChunkerTestCase(BaseTestCase):
    method test_chunkify (line 14) | def test_chunkify(self):
    method test_buzhash (line 55) | def test_buzhash(self):
    method test_small_reads (line 64) | def test_small_reads(self):

FILE: src/borg/testsuite/chunkers/buzhash_test.py
  function H (line 14) | def H(data):
  function test_chunkpoints_unchanged (line 18) | def test_chunkpoints_unchanged():
  function test_buzhash_chunksize_distribution (line 48) | def test_buzhash_chunksize_distribution():
  function test_fuzz_buzhash (line 77) | def test_fuzz_buzhash(worker):

FILE: src/borg/testsuite/chunkers/failing_test.py
  function test_chunker_failing (line 9) | def test_chunker_failing():

FILE: src/borg/testsuite/chunkers/fixed_self_test.py
  class ChunkerFixedTestCase (line 12) | class ChunkerFixedTestCase(BaseTestCase):
    method test_chunkify_just_blocks (line 13) | def test_chunkify_just_blocks(self):
    method test_chunkify_header_and_blocks (line 19) | def test_chunkify_header_and_blocks(self):
    method test_chunkify_just_blocks_fmap_complete (line 27) | def test_chunkify_just_blocks_fmap_complete(self):
    method test_chunkify_header_and_blocks_fmap_complete (line 34) | def test_chunkify_header_and_blocks_fmap_complete(self):
    method test_chunkify_header_and_blocks_fmap_zeros (line 43) | def test_chunkify_header_and_blocks_fmap_zeros(self):
    method test_chunkify_header_and_blocks_fmap_partial (line 51) | def test_chunkify_header_and_blocks_fmap_partial(self):

FILE: src/borg/testsuite/chunkers/fixed_test.py
  function test_chunkify_sparse (line 35) | def test_chunkify_sparse(tmpdir, fname, sparse_map, header_size, sparse):
  function test_fuzz_fixed (line 48) | def test_fuzz_fixed(worker):

FILE: src/borg/testsuite/chunkers/interaction_test.py
  function test_reader_chunker_interaction (line 21) | def test_reader_chunker_interaction(chunker_params):

FILE: src/borg/testsuite/chunkers/reader_test.py
  function test_sparsemap (line 17) | def test_sparsemap(tmpdir, fname, sparse_map):
  function test_filereader_read_simple (line 46) | def test_filereader_read_simple(file_content, read_size, expected_data, ...
  function test_filereader_read_multiple (line 77) | def test_filereader_read_multiple(file_content, read_sizes, expected_res...
  function test_filereader_read_with_mock (line 111) | def test_filereader_read_with_mock(mock_chunks, read_size, expected_data...
  function test_filefmapreader_basic (line 171) | def test_filefmapreader_basic(file_content, read_size, expected_chunks):
  function test_filefmapreader_with_fmap (line 229) | def test_filefmapreader_with_fmap(file_content, fmap, read_size, expecte...
  function test_filefmapreader_allocation_types (line 250) | def test_filefmapreader_allocation_types(zeros_length, read_size, expect...
  function test_filefmapreader_with_real_sparse_file (line 267) | def test_filefmapreader_with_real_sparse_file(tmpdir):
  function test_filefmapreader_build_fmap (line 315) | def test_filefmapreader_build_fmap():

FILE: src/borg/testsuite/cockpit_test.py
  function test_cockpit_app_create_archive (line 18) | def test_cockpit_app_create_archive(tmp_path):

FILE: src/borg/testsuite/compress_test.py
  function test_get_compressor (line 19) | def test_get_compressor(c_type, expected_compressor):
  function test_compression_types (line 29) | def test_compression_types(c_type):
  function test_lz4_buffer_allocation (line 40) | def test_lz4_buffer_allocation(monkeypatch):
  function test_autodetect_invalid (line 53) | def test_autodetect_invalid(invalid_cdata):
  function test_zlib_legacy_compat (line 58) | def test_zlib_legacy_compat():
  function test_compressor (line 84) | def test_compressor(c_params):
  function test_auto (line 99) | def test_auto():
  function test_factor_obfuscation (line 129) | def test_factor_obfuscation(specs, c_type, result_range, obfuscation_fac...
  function test_additive_obfuscation (line 154) | def test_additive_obfuscation(specs, c_type, obfuscation_padding: int):
  function test_obfuscate_meta (line 170) | def test_obfuscate_meta():
  function test_default_compression_level (line 192) | def test_default_compression_level(c_type, c_name):
  function test_specified_compression_level (line 204) | def test_specified_compression_level(c_type, c_name, c_levels):
  function test_invalid_compression_level (line 212) | def test_invalid_compression_level(invalid_spec):
  function test_padme_obfuscation (line 235) | def test_padme_obfuscation(data_length, expected_padding):
  function test_robj_specific_obfuscation (line 254) | def test_robj_specific_obfuscation(data_length, expected_padding, robj_t...

FILE: src/borg/testsuite/crypto/crypto_test.py
  class CryptoTestCase (line 17) | class CryptoTestCase(BaseTestCase):
    method test_bytes_to_int (line 18) | def test_bytes_to_int(self):
    method test_bytes_to_long (line 21) | def test_bytes_to_long(self):
    method test_UNENCRYPTED (line 25) | def test_UNENCRYPTED(self):
    method test_AES256_CTR_HMAC_SHA256 (line 35) | def test_AES256_CTR_HMAC_SHA256(self):
    method test_AES256_CTR_HMAC_SHA256_aad (line 64) | def test_AES256_CTR_HMAC_SHA256_aad(self):
    method test_AE (line 92) | def test_AE(self):
    method test_AEAD (line 135) | def test_AEAD(self):
    method test_AEAD_with_more_AAD (line 178) | def test_AEAD_with_more_AAD(self):
  function test_decrypt_key_file_argon2_chacha20_poly1305 (line 198) | def test_decrypt_key_file_argon2_chacha20_poly1305():
  function test_decrypt_key_file_pbkdf2_sha256_aes256_ctr_hmac_sha256 (line 225) | def test_decrypt_key_file_pbkdf2_sha256_aes256_ctr_hmac_sha256():
  function test_repo_key_detect_does_not_raise_integrity_error (line 243) | def test_repo_key_detect_does_not_raise_integrity_error(getpass, monkeyp...
  class TestDeriveKey (line 282) | class TestDeriveKey(BaseTestCase):
    class CustomKey (line 284) | class CustomKey(KeyBase):
      method __init__ (line 285) | def __init__(self, crypt_key, id_key):
    method test_derive_key_with_plaintext_key (line 289) | def test_derive_key_with_plaintext_key(self):
    method test_derive_key_with_custom_key (line 299) | def test_derive_key_with_custom_key(self):
    method test_derive_key_from_different_keys (line 320) | def test_derive_key_from_different_keys(self):

FILE: src/borg/testsuite/crypto/csprng_test.py
  function test_deterministic_output (line 11) | def test_deterministic_output():
  function test_random_bytes (line 30) | def test_random_bytes():
  function test_random_int (line 45) | def test_random_int():
  function test_random_int_edge_cases (line 62) | def test_random_int_edge_cases():
  function test_shuffle (line 106) | def test_shuffle():
  function test_statistical_properties (line 137) | def test_statistical_properties():
  function test_large_shuffle (line 166) | def test_large_shuffle():

FILE: src/borg/testsuite/crypto/file_integrity_test.py
  class TestReadIntegrityFile (line 7) | class TestReadIntegrityFile:
    method test_no_integrity (line 8) | def test_no_integrity(self, tmpdir):
    method test_truncated_integrity (line 13) | def test_truncated_integrity(self, tmpdir):
    method test_unknown_algorithm (line 20) | def test_unknown_algorithm(self, tmpdir):
    method test_malformed (line 29) | def test_malformed(self, tmpdir, json):
  class TestDetachedIntegrityCheckedFile (line 37) | class TestDetachedIntegrityCheckedFile:
    method integrity_protected_file (line 39) | def integrity_protected_file(self, tmpdir):
    method test_simple (line 45) | def test_simple(self, tmpdir, integrity_protected_file):
    method test_corrupted_file (line 51) | def test_corrupted_file(self, integrity_protected_file):
    method test_corrupted_file_partial_read (line 58) | def test_corrupted_file_partial_read(self, integrity_protected_file):
    method test_renamed_file (line 67) | def test_renamed_file(self, tmpdir, integrity_protected_file, new_name):
    method test_moved_file (line 75) | def test_moved_file(self, tmpdir, integrity_protected_file):
    method test_no_integrity (line 83) | def test_no_integrity(self, tmpdir, integrity_protected_file):
  class TestDetachedIntegrityCheckedFileParts (line 89) | class TestDetachedIntegrityCheckedFileParts:
    method integrity_protected_file (line 91) | def integrity_protected_file(self, tmpdir):
    method test_simple (line 99) | def test_simple(self, integrity_protected_file):
    method test_wrong_part_name (line 106) | def test_wrong_part_name(self, integrity_protected_file):
    method test_part_independence (line 120) | def test_part_independence(self, integrity_protected_file, partial_read):
  class TestIntegrityCheckedFileWithSyncFile (line 136) | class TestIntegrityCheckedFileWithSyncFile:
    method test_write_and_verify_with_syncfile (line 137) | def test_write_and_verify_with_syncfile(self, tmp_path):

FILE: src/borg/testsuite/crypto/key_test.py
  class TestKey (line 23) | class TestKey:
    class MockArgs (line 24) | class MockArgs:
    method keys_dir (line 70) | def keys_dir(self, request, monkeypatch, tmpdir):
    method key (line 96) | def key(self, request, monkeypatch):
    class MockRepository (line 100) | class MockRepository:
      class _Location (line 101) | class _Location:
        method canonical_path (line 104) | def canonical_path(self):
      method save_key (line 112) | def save_key(self, data):
      method load_key (line 115) | def load_key(self):
    method test_plaintext (line 118) | def test_plaintext(self):
    method test_keyfile (line 125) | def test_keyfile(self, monkeypatch, keys_dir):
    method test_keyfile_kfenv (line 147) | def test_keyfile_kfenv(self, tmpdir, monkeypatch):
    method test_keyfile2 (line 163) | def test_keyfile2(self, monkeypatch, keys_dir):
    method test_keyfile2_kfenv (line 170) | def test_keyfile2_kfenv(self, tmpdir, monkeypatch):
    method test_keyfile_blake2 (line 179) | def test_keyfile_blake2(self, monkeypatch, keys_dir):
    method _corrupt_byte (line 186) | def _corrupt_byte(self, key, data, offset):
    method test_decrypt_integrity (line 194) | def test_decrypt_integrity(self, monkeypatch, keys_dir):
    method test_roundtrip (line 211) | def test_roundtrip(self, key):
    method test_assert_id (line 222) | def test_assert_id(self, key):
    method test_authenticated_encrypt (line 235) | def test_authenticated_encrypt(self, monkeypatch):
    method test_blake2_authenticated_encrypt (line 246) | def test_blake2_authenticated_encrypt(self, monkeypatch):
  class TestTAM (line 258) | class TestTAM:
    method key (line 260) | def key(self, monkeypatch):
    method test_unpack_future (line 264) | def test_unpack_future(self, key):
    method test_round_trip_manifest (line 273) | def test_round_trip_manifest(self, key):
    method test_round_trip_archive (line 280) | def test_round_trip_archive(self, key):
  function test_decrypt_key_file_unsupported_algorithm (line 288) | def test_decrypt_key_file_unsupported_algorithm():
  function test_decrypt_key_file_v2_is_unsupported (line 297) | def test_decrypt_key_file_v2_is_unsupported():
  function test_key_file_roundtrip (line 306) | def test_key_file_roundtrip(monkeypatch):

FILE: src/borg/testsuite/fslocking_test.py
  function free_pid (line 32) | def free_pid():
  class TestTimeoutTimer (line 42) | class TestTimeoutTimer:
    method test_timeout (line 43) | def test_timeout(self):
    method test_notimeout_sleep (line 50) | def test_notimeout_sleep(self):
  function lockpath (line 60) | def lockpath(tmpdir):
  class TestExclusiveLock (line 64) | class TestExclusiveLock:
    method test_checks (line 65) | def test_checks(self, lockpath):
    method test_acquire_break_reacquire (line 69) | def test_acquire_break_reacquire(self, lockpath):
    method test_timeout (line 75) | def test_timeout(self, lockpath):
    method test_kill_stale (line 80) | def test_kill_stale(self, lockpath, free_pid):
    method test_migrate_lock (line 96) | def test_migrate_lock(self, lockpath):
    method test_race_condition (line 110) | def test_race_condition(self, lockpath):
  class TestLock (line 215) | class TestLock:
    method test_shared (line 216) | def test_shared(self, lockpath):
    method test_exclusive (line 226) | def test_exclusive(self, lockpath):
    method test_upgrade (line 232) | def test_upgrade(self, lockpath):
    method test_downgrade (line 240) | def test_downgrade(self, lockpath):
    method test_got_exclusive_lock (line 247) | def test_got_exclusive_lock(self, lockpath):
    method test_break (line 255) | def test_break(self, lockpath):
    method test_timeout (line 263) | def test_timeout(self, lockpath):
    method test_kill_stale (line 274) | def test_kill_stale(self, lockpath, free_pid):
    method test_migrate_lock (line 293) | def test_migrate_lock(self, lockpath):
  function rosterpath (line 311) | def rosterpath(tmpdir):
  class TestLockRoster (line 315) | class TestLockRoster:
    method test_empty (line 316) | def test_empty(self, rosterpath):
    method test_modify_get (line 322) | def test_modify_get(self, rosterpath):
    method test_kill_stale (line 337) | def test_kill_stale(self, rosterpath, free_pid):
    method test_migrate_lock (line 366) | def test_migrate_lock(self, rosterpath):

FILE: src/borg/testsuite/hashindex_test.py
  function H (line 9) | def H(x):
  function H2 (line 14) | def H2(x):
  function test_chunkindex_add (line 19) | def test_chunkindex_add():
  function test_keyerror (line 32) | def test_keyerror():
  function test_new (line 41) | def test_new():

FILE: src/borg/testsuite/helpers/__init__test.py
  function test_classify_ec (line 19) | def test_classify_ec(ec_range, ec_class):
  function test_ec_invalid (line 24) | def test_ec_invalid():
  function test_max_ec (line 63) | def test_max_ec(ec1, ec2, ec_max):

FILE: src/borg/testsuite/helpers/datastruct_test.py
  function test_stable_dict (line 8) | def test_stable_dict():
  class TestBuffer (line 14) | class TestBuffer:
    method test_type (line 15) | def test_type(self):
    method test_len (line 21) | def test_len(self):
    method test_resize (line 29) | def test_resize(self):
    method test_limit (line 46) | def test_limit(self):
    method test_get (line 54) | def test_get(self):

FILE: src/borg/testsuite/helpers/efficient_collection_queue_test.py
  class TestEfficientQueue (line 6) | class TestEfficientQueue:
    method test_base_usage (line 7) | def test_base_usage(self):
    method test_usage_with_arrays (line 19) | def test_usage_with_arrays(self):
    method test_chunking (line 31) | def test_chunking(self):

FILE: src/borg/testsuite/helpers/fs_test.py
  function test_get_base_dir (line 30) | def test_get_base_dir(monkeypatch):
  function test_get_base_dir_compat (line 51) | def test_get_base_dir_compat(monkeypatch):
  function test_get_config_dir (line 62) | def test_get_config_dir(monkeypatch):
  function test_get_config_dir_compat (line 86) | def test_get_config_dir_compat(monkeypatch):
  function test_get_cache_dir (line 105) | def test_get_cache_dir(monkeypatch):
  function test_get_cache_dir_compat (line 129) | def test_get_cache_dir_compat(monkeypatch):
  function test_get_keys_dir (line 148) | def test_get_keys_dir(monkeypatch):
  function test_get_security_dir (line 172) | def test_get_security_dir(monkeypatch):
  function test_get_runtime_dir (line 207) | def test_get_runtime_dir(monkeypatch):
  function test_dash_open (line 237) | def test_dash_open():
  function test_safe_unlink_is_safe (line 245) | def test_safe_unlink_is_safe(tmpdir):
  function test_safe_unlink_is_safe_ENOSPC (line 258) | def test_safe_unlink_is_safe_ENOSPC(tmpdir, monkeypatch):
  function test_remove_dotdot_prefixes (line 289) | def test_remove_dotdot_prefixes(original_path, expected_path):
  function test_valid_make_path_safe (line 311) | def test_valid_make_path_safe(original_path, expected_path):
  function test_invalid_make_path_safe (line 316) | def test_invalid_make_path_safe(path):
  function test_make_path_safe_win32_drive_letters (line 321) | def test_make_path_safe_win32_drive_letters(monkeypatch):
  function test_dir_is_tagged (line 338) | def test_dir_is_tagged(tmpdir):
  function test_map_chars (line 465) | def test_map_chars(monkeypatch):

FILE: src/borg/testsuite/helpers/lrucache_test.py
  class TestLRUCache (line 8) | class TestLRUCache:
    method test_lrucache (line 9) | def test_lrucache(self):
    method test_dispose (line 38) | def test_dispose(self):

FILE: src/borg/testsuite/helpers/misc_test.py
  function test_chunk_file_wrapper (line 8) | def test_chunk_file_wrapper():
  function test_chunkit (line 19) | def test_chunkit():
  function test_iter_separated (line 36) | def test_iter_separated():

FILE: src/borg/testsuite/helpers/msgpack_test.py
  function expected_py_mp_slow_combination (line 8) | def expected_py_mp_slow_combination():
  function test_is_slow_msgpack (line 24) | def test_is_slow_msgpack():

FILE: src/borg/testsuite/helpers/nanorst_test.py
  function test_inline (line 6) | def test_inline():
  function test_inline_spread (line 10) | def test_inline_spread():
  function test_comment_inline (line 14) | def test_comment_inline():
  function test_inline_escape (line 18) | def test_inline_escape():
  function test_comment (line 22) | def test_comment():
  function test_directive_note (line 26) | def test_directive_note():
  function test_ref (line 30) | def test_ref():
  function test_undefined_ref (line 35) | def test_undefined_ref():

FILE: src/borg/testsuite/helpers/parseformat_test.py
  function test_bin_to_hex (line 33) | def test_bin_to_hex():
  function test_binary_to_json (line 42) | def test_binary_to_json(key, value):
  function test_text_to_json (line 59) | def test_text_to_json(key, value, strict):
  class TestLocationWithoutEnv (line 78) | class TestLocationWithoutEnv:
    method keys_dir (line 80) | def keys_dir(self, tmpdir, monkeypatch):
    method test_ssh (line 87) | def test_ssh(self, monkeypatch, keys_dir):
    method test_s3 (line 155) | def test_s3(self, monkeypatch, keys_dir):
    method test_rclone (line 174) | def test_rclone(self, monkeypatch, keys_dir):
    method test_sftp (line 182) | def test_sftp(self, monkeypatch, keys_dir):
    method test_http (line 197) | def test_http(self, monkeypatch, keys_dir):
    method test_socket (line 205) | def test_socket(self, monkeypatch, keys_dir):
    method test_file (line 215) | def test_file(self, monkeypatch, keys_dir):
    method test_smb (line 225) | def test_smb(self, monkeypatch, keys_dir):
    method test_folder (line 233) | def test_folder(self, monkeypatch, keys_dir):
    method test_abspath (line 244) | def test_abspath(self, monkeypatch, keys_dir):
    method test_relpath (line 257) | def test_relpath(self, monkeypatch, keys_dir):
    method test_with_colons (line 274) | def test_with_colons(self, monkeypatch, keys_dir):
    method test_canonical_path (line 292) | def test_canonical_path(self, monkeypatch):
    method test_bad_syntax (line 312) | def test_bad_syntax(self):
  function test_archivename_ok (line 326) | def test_archivename_ok(name):
  function test_archivename_invalid (line 354) | def test_archivename_invalid(name):
  function test_text_ok (line 360) | def test_text_ok(text):
  function test_text_invalid (line 375) | def test_text_invalid(text):
  function test_format_timedelta (line 382) | def test_format_timedelta():
  function test_interval (line 400) | def test_interval(timeframe, num_secs):
  function test_interval_time_unit (line 412) | def test_interval_time_unit(invalid_interval, error_tuple):
  function test_interval_number (line 418) | def test_interval_number():
  function test_parse_timestamp (line 424) | def test_parse_timestamp():
  function test_file_size (line 455) | def test_file_size(size, fmt):
  function test_file_size_iec (line 478) | def test_file_size_iec(size, fmt):
  function test_file_size_precision (line 491) | def test_file_size_precision(original_size, formatted_size):
  function test_file_size_sign (line 496) | def test_file_size_sign(size, fmt):
  function test_parse_file_size (line 503) | def test_parse_file_size(string, value):
  function test_parse_file_size_invalid (line 508) | def test_parse_file_size_invalid(string):
  function test_partial_format (line 523) | def test_partial_format(fmt, items_map, expected_result):
  function test_clean_lines (line 527) | def test_clean_lines():
  function test_format_line (line 544) | def test_format_line():
  function test_format_line_erroneous (line 551) | def test_format_line_erroneous():
  function test_replace_placeholders (line 563) | def test_replace_placeholders():
  function test_override_placeholders (line 570) | def test_override_placeholders():
  function working_swidth (line 574) | def working_swidth():
  function test_swidth_slice (line 581) | def test_swidth_slice():
  function test_swidth_slice_mixed_characters (line 590) | def test_swidth_slice_mixed_characters():
  function test_eval_escapes (line 596) | def test_eval_escapes():
  function test_valid_chunkerparams (line 625) | def test_valid_chunkerparams(chunker_params, expected_return):
  function test_invalid_chunkerparams (line 642) | def test_invalid_chunkerparams(invalid_chunker_params):

FILE: src/borg/testsuite/helpers/passphrase_test.py
  class TestPassphrase (line 8) | class TestPassphrase:
    method test_passphrase_new_verification (line 9) | def test_passphrase_new_verification(self, capsys, monkeypatch):
    method test_passphrase_new_empty (line 30) | def test_passphrase_new_empty(self, capsys, monkeypatch):
    method test_passphrase_new_retries (line 38) | def test_passphrase_new_retries(self, monkeypatch):
    method test_passphrase_repr (line 45) | def test_passphrase_repr(self):
    method test_passphrase_wrong_debug (line 48) | def test_passphrase_wrong_debug(self, capsys, monkeypatch):
    method test_verification (line 72) | def test_verification(self, capsys, monkeypatch):

FILE: src/borg/testsuite/helpers/process_test.py
  class TestPopenWithErrorHandling (line 7) | class TestPopenWithErrorHandling:
    method test_simple (line 9) | def test_simple(self):
    method test_not_found (line 16) | def test_not_found(self):
    method test_bad_syntax (line 21) | def test_bad_syntax(self, cmd):
    method test_shell (line 25) | def test_shell(self):

FILE: src/borg/testsuite/helpers/progress_test.py
  function test_progress_percentage (line 4) | def test_progress_percentage(capfd):
  function test_progress_percentage_step (line 22) | def test_progress_percentage_step(capfd):
  function test_progress_percentage_quiet (line 36) | def test_progress_percentage_quiet(capfd):

FILE: src/borg/testsuite/helpers/shellpattern_test.py
  function check (line 8) | def check(path, pattern):
  function test_match (line 81) | def test_match(path, patterns):
  function test_mismatch (line 119) | def test_mismatch(path, patterns):
  function test_match_end (line 124) | def test_match_end():

FILE: src/borg/testsuite/helpers/time_test.py
  function utcfromtimestamp (line 7) | def utcfromtimestamp(timestamp):
  function test_safe_timestamps (line 12) | def test_safe_timestamps():

FILE: src/borg/testsuite/helpers/yes_no_test.py
  function test_yes_input (line 7) | def test_yes_input():
  function test_yes_input_defaults (line 18) | def test_yes_input_defaults():
  function test_yes_input_custom (line 28) | def test_yes_input_custom():
  function test_yes_env (line 35) | def test_yes_env(monkeypatch):
  function test_yes_env_default (line 44) | def test_yes_env_default(monkeypatch):
  function test_yes_defaults (line 51) | def test_yes_defaults():
  function test_yes_retry (line 67) | def test_yes_retry():
  function test_yes_no_retry (line 74) | def test_yes_no_retry():
  function test_yes_output (line 81) | def test_yes_output(capfd):
  function test_yes_env_output (line 97) | def test_yes_env_output(capfd, monkeypatch):

FILE: src/borg/testsuite/item_test.py
  function test_item_empty (line 9) | def test_item_empty():
  function test_item_from_dict (line 45) | def test_item_from_dict(item_dict, path, mode):
  function test_item_invalid (line 61) | def test_item_invalid(invalid_item, error):
  function test_item_from_kw (line 66) | def test_item_from_kw():
  function test_item_int_property (line 72) | def test_item_int_property():
  function test_item_mptimestamp_property (line 84) | def test_item_mptimestamp_property(atime):
  function test_item_se_str_property (line 91) | def test_item_se_str_property():
  function test_item_list_property (line 112) | def test_item_list_property():
  function test_item_dict_property (line 123) | def test_item_dict_property():
  function test_unknown_property (line 134) | def test_unknown_property():
  function test_item_file_size (line 143) | def test_item_file_size():
  function test_item_file_size_no_chunks (line 150) | def test_item_file_size_no_chunks():
  function test_item_optr (line 155) | def test_item_optr():
  function test_chunk_content_equal (line 169) | def test_chunk_content_equal(chunk_a: str, chunk_b: str, chunks_equal):

FILE: src/borg/testsuite/legacyrepository_test.py
  function repository (line 24) | def repository(tmp_path):
  function remote_repository (line 30) | def remote_repository(tmp_path):
  function pytest_generate_tests (line 37) | def pytest_generate_tests(metafunc):
  function get_repository_from_fixture (line 43) | def get_repository_from_fixture(repo_fixtures, request):
  function reopen (line 48) | def reopen(repository, exclusive: bool | None = True, create=False):
  function get_path (line 64) | def get_path(repository):
  function fchunk (line 76) | def fchunk(data, meta=b""):
  function pchunk (line 84) | def pchunk(chunk):
  function pdchunk (line 94) | def pdchunk(chunk):
  function add_keys (line 99) | def add_keys(repository):
  function repo_dump (line 109) | def repo_dump(repository, label=None):
  function test_basic_operations (line 120) | def test_basic_operations(repo_fixtures, request):
  function test_multiple_transactions (line 139) | def test_multiple_transactions(repo_fixtures, request):
  function test_read_data (line 150) | def test_read_data(repo_fixtures, request):
  function test_consistency (line 163) | def test_consistency(repo_fixtures, request):
  function test_consistency2 (line 176) | def test_consistency2(repo_fixtures, request):
  function test_overwrite_in_same_transaction (line 187) | def test_overwrite_in_same_transaction(repo_fixtures, request):
  function test_single_kind_transactions (line 195) | def test_single_kind_transactions(repo_fixtures, request):
  function test_list (line 210) | def test_list(repo_fixtures, request):
  function test_max_data_size (line 226) | def test_max_data_size(repo_fixtures, request):
  function _assert_sparse (line 236) | def _assert_sparse(repository):
  function test_sparse1 (line 247) | def test_sparse1(repository):
  function test_sparse2 (line 256) | def test_sparse2(repository):
  function test_sparse_delete (line 265) | def test_sparse_delete(repository):
  function test_uncommitted_garbage (line 280) | def test_uncommitted_garbage(repository):
  function test_replay_of_missing_index (line 297) | def test_replay_of_missing_index(repository):
  function test_crash_before_compact_segments (line 308) | def test_crash_before_compact_segments(repository):
  function test_crash_before_write_index (line 321) | def test_crash_before_write_index(repository):
  function test_replay_lock_upgrade_old (line 334) | def test_replay_lock_upgrade_old(repository):
  function test_replay_lock_upgrade (line 350) | def test_replay_lock_upgrade(repository):
  function test_crash_before_deleting_compacted_segments (line 366) | def test_crash_before_deleting_compacted_segments(repository):
  function test_ignores_commit_tag_in_data (line 380) | def test_ignores_commit_tag_in_data(repository):
  function test_moved_deletes_are_tracked (line 388) | def test_moved_deletes_are_tracked(repository):
  function test_shadowed_entries_are_preserved1 (line 419) | def test_shadowed_entries_are_preserved1(repository):
  function test_shadowed_entries_are_preserved2 (line 450) | def test_shadowed_entries_are_preserved2(repository):
  function test_shadow_index_rollback (line 494) | def test_shadow_index_rollback(repository):
  function test_additional_free_space (line 515) | def test_additional_free_space(repository):
  function test_create_free_space (line 527) | def test_create_free_space(repository):
  function make_auxiliary (line 535) | def make_auxiliary(repository):
  function do_commit (line 541) | def do_commit(repository):
  function test_corrupted_hints (line 547) | def test_corrupted_hints(repository):
  function test_deleted_hints (line 554) | def test_deleted_hints(repository):
  function test_deleted_index (line 560) | def test_deleted_index(repository):
  function test_unreadable_hints (line 566) | def test_unreadable_hints(repository):
  function _corrupt_index (line 575) | def _corrupt_index(repository):
  function test_index_corrupted_without_integrity (line 590) | def test_index_corrupted_without_integrity(repository):
  function test_unreadable_index (line 603) | def test_unreadable_index(repository):
  function test_unknown_integrity_version (line 612) | def test_unknown_integrity_version(repository):
  function _subtly_corrupted_hints_setup (line 625) | def _subtly_corrupted_hints_setup(repository):
  function test_subtly_corrupted_hints (line 645) | def test_subtly_corrupted_hints(repository):
  function test_subtly_corrupted_hints_without_integrity (line 658) | def test_subtly_corrupted_hints_without_integrity(repository, caplog):
  function list_indices (line 674) | def list_indices(repo_path):
  function check (line 678) | def check(repository, repo_path, repair=False, status=True):
  function get_objects (line 685) | def get_objects(repository, *ids):
  function add_objects (line 690) | def add_objects(repository, segments):
  function get_head (line 697) | def get_head(repo_path):
  function open_index (line 701) | def open_index(repo_path):
  function corrupt_object (line 705) | def corrupt_object(repo_path, id_):
  function delete_segment (line 713) | def delete_segment(repository, segment):
  function delete_index (line 717) | def delete_index(repo_path):
  function rename_index (line 721) | def rename_index(repo_path, new_name):
  function list_objects (line 725) | def list_objects(repository):
  function test_repair_corrupted_segment (line 729) | def test_repair_corrupted_segment(repo_fixtures, request):
  function test_repair_missing_segment (line 749) | def test_repair_missing_segment(repository):
  function test_repair_missing_commit_segment (line 761) | def test_repair_missing_commit_segment(repository):
  function test_repair_corrupted_commit_segment (line 771) | def test_repair_corrupted_commit_segment(repo_fixtures, request):
  function test_repair_no_commits (line 785) | def test_repair_no_commits(repo_fixtures, request):
  function test_repair_missing_index (line 804) | def test_repair_missing_index(repo_fixtures, request):
  function test_repair_index_too_new (line 814) | def test_repair_index_too_new(repo_fixtures, request):
  function test_crash_before_compact (line 826) | def test_crash_before_compact(repository):
  function test_hints_persistence (line 840) | def test_hints_persistence(repository):
  function test_hints_behaviour (line 868) | def test_hints_behaviour(repository):
  function _get_mock_args (line 888) | def _get_mock_args():
  function test_remote_invalid_rpc (line 902) | def test_remote_invalid_rpc(remote_repository):
  function test_remote_rpc_exception_transport (line 908) | def test_remote_rpc_exception_transport(remote_repository):
  function test_remote_ssh_cmd (line 964) | def test_remote_ssh_cmd(remote_repository):
  function test_remote_borg_cmd (line 980) | def test_remote_borg_cmd(remote_repository):

FILE: src/borg/testsuite/logger_test.py
  function io_logger (line 12) | def io_logger():
  function test_setup_logging (line 20) | def test_setup_logging(io_logger):
  function test_multiple_loggers (line 25) | def test_multiple_loggers(io_logger):
  function test_parent_module (line 41) | def test_parent_module():
  function test_lazy_logger (line 45) | def test_lazy_logger():

FILE: src/borg/testsuite/patterns_test.py
  function check_patterns (line 14) | def check_patterns(files, pattern, expected):
  function test_patterns_full (line 36) | def test_patterns_full(pattern, expected):
  function test_patterns_full_relative (line 52) | def test_patterns_full_relative(pattern, expected):
  function test_patterns_prefix (line 73) | def test_patterns_prefix(pattern, expected):
  function test_patterns_prefix_relative (line 99) | def test_patterns_prefix_relative(pattern, expected):
  function test_patterns_fnmatch (line 163) | def test_patterns_fnmatch(pattern, expected):
  function test_patterns_shell (line 251) | def test_patterns_shell(pattern, expected):
  function test_patterns_regex (line 295) | def test_patterns_regex(pattern, expected):
  function test_regex_pattern (line 317) | def test_regex_pattern():
  function use_normalized_unicode (line 324) | def use_normalized_unicode():
  function _make_test_patterns (line 328) | def _make_test_patterns(pattern):
  function test_composed_unicode_pattern (line 338) | def test_composed_unicode_pattern(pattern):
  function test_decomposed_unicode_pattern (line 344) | def test_decomposed_unicode_pattern(pattern):
  function test_invalid_unicode_pattern (line 350) | def test_invalid_unicode_pattern(pattern):
  function test_exclude_patterns_from_file (line 410) | def test_exclude_patterns_from_file(tmpdir, lines, expected):
  function test_load_patterns_from_file (line 442) | def test_load_patterns_from_file(tmpdir, lines, expected_roots, expected...
  function test_switch_patterns_style (line 460) | def test_switch_patterns_style():
  function test_load_invalid_patterns_from_file (line 489) | def test_load_invalid_patterns_from_file(tmpdir, lines):
  function test_inclexcl_patterns_from_file (line 533) | def test_inclexcl_patterns_from_file(tmpdir, lines, expected):
  function test_parse_pattern (line 590) | def test_parse_pattern(pattern, cls):
  function test_parse_pattern_error (line 595) | def test_parse_pattern_error(pattern):
  function test_pattern_matcher (line 600) | def test_pattern_matcher():
  function test_regex_from_pattern (line 638) | def test_regex_from_pattern(pattern, regex):

FILE: src/borg/testsuite/platform/all_test.py
  function test_swidth_ascii (line 6) | def test_swidth_ascii():
  function test_swidth_cjk (line 10) | def test_swidth_cjk():
  function test_swidth_mixed (line 14) | def test_swidth_mixed():
  function test_syncfile_seek_tell (line 18) | def test_syncfile_seek_tell(tmp_path):
  function test_syncfile_close_idempotent (line 34) | def test_syncfile_close_idempotent(tmp_path):

FILE: src/borg/testsuite/platform/darwin_test.py
  function get_acl (line 12) | def get_acl(path, numeric_ids=False):
  function set_acl (line 18) | def set_acl(path, acl, numeric_ids=False):
  function test_extended_acl (line 24) | def test_extended_acl():
  function test_fdatasync_uses_f_fullfsync (line 52) | def test_fdatasync_uses_f_fullfsync(monkeypatch):
  function test_fdatasync_falls_back_to_fsync (line 74) | def test_fdatasync_falls_back_to_fsync(monkeypatch):
  function test_fdatasync_basic (line 100) | def test_fdatasync_basic():
  function test_sync_dir_basic (line 108) | def test_sync_dir_basic():

FILE: src/borg/testsuite/platform/freebsd_test.py
  function get_acl (line 38) | def get_acl(path, numeric_ids=False):
  function set_acl (line 44) | def set_acl(path, access=None, default=None, nfs4=None, numeric_ids=False):
  function test_access_acl (line 50) | def test_access_acl():
  function test_default_acl (line 88) | def test_default_acl():

FILE: src/borg/testsuite/platform/linux_test.py
  function get_acl (line 38) | def get_acl(path, numeric_ids=False):
  function set_acl (line 44) | def set_acl(path, access=None, default=None, numeric_ids=False):
  function test_access_acl (line 50) | def test_access_acl():
  function test_default_acl (line 74) | def test_default_acl():
  function test_non_ascii_acl (line 84) | def test_non_ascii_acl():
  function test_utils (line 118) | def test_utils():
  function test_numeric_to_named_with_id_simple (line 127) | def test_numeric_to_named_with_id_simple(monkeypatch):
  function test_numeric_to_named_with_id_nonexistent_ids (line 158) | def test_numeric_to_named_with_id_nonexistent_ids(monkeypatch):
  function test_numeric_to_numeric_with_id_simple (line 180) | def test_numeric_to_numeric_with_id_simple():

FILE: src/borg/testsuite/platform/platform_test.py
  function fakeroot_detected (line 14) | def fakeroot_detected():
  function user_exists (line 18) | def user_exists(username):
  function are_acls_working (line 31) | def are_acls_working():
  function test_process_alive (line 81) | def test_process_alive(free_pid):  # NOQA
  function test_process_id (line 90) | def test_process_id():

FILE: src/borg/testsuite/platform/windows_test.py
  function test_syncfile_basic (line 12) | def test_syncfile_basic(tmp_path):
  function test_syncfile_file_exists_error (line 20) | def test_syncfile_file_exists_error(tmp_path):
  function test_syncfile_text_mode (line 28) | def test_syncfile_text_mode(tmp_path):
  function test_syncfile_fd_fallback (line 36) | def test_syncfile_fd_fallback(tmp_path):
  function test_syncfile_sync (line 45) | def test_syncfile_sync(tmp_path):
  function test_syncfile_uses_write_through (line 53) | def test_syncfile_uses_write_through(tmp_path, monkeypatch):

FILE: src/borg/testsuite/remote_test.py
  class TestSleepingBandwidthLimiter (line 20) | class TestSleepingBandwidthLimiter:
    method expect_write (line 21) | def expect_write(self, fd, data):
    method check_write (line 25) | def check_write(self, fd, data):
    method test_write_unlimited (line 30) | def test_write_unlimited(self, monkeypatch):
    method test_write (line 37) | def test_write(self, monkeypatch):
  class TestRepositoryCache (line 74) | class TestRepositoryCache:
    method repository (line 76) | def repository(self, tmpdir):
    method cache (line 85) | def cache(self, repository):
    method test_simple (line 88) | def test_simple(self, cache: RepositoryCache):
    method test_meta (line 106) | def test_meta(self, cache: RepositoryCache):
    method test_mixed (line 125) | def test_mixed(self, cache: RepositoryCache):
    method test_backoff (line 142) | def test_backoff(self, cache: RepositoryCache):
    method test_enospc (line 168) | def test_enospc(self, cache: RepositoryCache):
    method key (line 198) | def key(self, repository, monkeypatch):
    method repo_objs (line 204) | def repo_objs(self, key):
    method _put_encrypted_object (line 207) | def _put_encrypted_object(self, repo_objs, repository, data):
    method H1 (line 213) | def H1(self, repo_objs, repository):
    method H2 (line 217) | def H2(self, repo_objs, repository):
    method H3 (line 221) | def H3(self, repo_objs, repository):
    method decrypted_cache (line 225) | def decrypted_cache(self, repo_objs, repository):
    method test_cache_corruption (line 228) | def test_cache_corruption(self, decrypted_cache: RepositoryCache, H1, ...

FILE: src/borg/testsuite/repoobj_test.py
  function repository (line 12) | def repository(tmpdir):
  function key (line 17) | def key(repository):
  function test_format_parse_roundtrip (line 21) | def test_format_parse_roundtrip(key):
  function test_format_parse_roundtrip_borg1 (line 44) | def test_format_parse_roundtrip_borg1(key):  # legacy
  function test_borg1_borg2_transition (line 64) | def test_borg1_borg2_transition(key):
  function test_spoof_manifest (line 109) | def test_spoof_manifest(key):
  function test_spoof_archive (line 121) | def test_spoof_archive(key):

FILE: src/borg/testsuite/repository_test.py
  function repository (line 18) | def repository(tmp_path):
  function remote_repository (line 24) | def remote_repository(tmp_path):
  function pytest_generate_tests (line 31) | def pytest_generate_tests(metafunc):
  function get_repository_from_fixture (line 37) | def get_repository_from_fixture(repo_fixtures, request):
  function reopen (line 42) | def reopen(repository, exclusive: bool | None = True, create=False):
  function fchunk (line 58) | def fchunk(data, meta=b""):
  function pchunk (line 66) | def pchunk(chunk):
  function pdchunk (line 76) | def pdchunk(chunk):
  function test_basic_operations (line 81) | def test_basic_operations(repo_fixtures, request):
  function test_read_data (line 99) | def test_read_data(repo_fixtures, request):
  function test_consistency (line 111) | def test_consistency(repo_fixtures, request):
  function test_list (line 124) | def test_list(repo_fixtures, request):
  function test_max_data_size (line 139) | def test_max_data_size(repo_fixtures, request):
  function check (line 149) | def check(repository, repo_path, repair=False, status=True):
  function _get_mock_args (line 156) | def _get_mock_args():
  function test_remote_invalid_rpc (line 170) | def test_remote_invalid_rpc(remote_repository):
  function test_remote_rpc_exception_transport (line 176) | def test_remote_rpc_exception_transport(remote_repository):
  function test_remote_ssh_cmd (line 238) | def test_remote_ssh_cmd(remote_repository):
  function test_remote_borg_cmd (line 254) | def test_remote_borg_cmd(remote_repository):

FILE: src/borg/testsuite/shell_completions_test.py
  function test_fish_completion_is_valid (line 9) | def test_fish_completion_is_valid():

FILE: src/borg/testsuite/storelocking_test.py
  function lockstore (line 15) | def lockstore(tmp_path):
  class TestLock (line 23) | class TestLock:
    method test_cm (line 24) | def test_cm(self, lockstore):
    method test_got_exclusive_lock (line 30) | def test_got_exclusive_lock(self, lockstore):
    method test_exclusive_lock (line 38) | def test_exclusive_lock(self, lockstore):
    method test_double_nonexclusive_lock_succeeds (line 48) | def test_double_nonexclusive_lock_succeeds(self, lockstore):
    method test_not_locked (line 53) | def test_not_locked(self, lockstore):
    method test_break_lock (line 61) | def test_break_lock(self, lockstore):
    method test_lock_refresh_stale_removal (line 69) | def test_lock_refresh_stale_removal(self, lockstore):
    method test_migrate_lock (line 89) | def test_migrate_lock(self, lockstore):

FILE: src/borg/testsuite/version_test.py
  function test_parse_version (line 29) | def test_parse_version(version_str, version_tuple):
  function test_parse_version_invalid (line 34) | def test_parse_version_invalid(invalid_version):
  function test_format_version (line 53) | def test_format_version(version_str, version_tuple):

FILE: src/borg/testsuite/xattr_test.py
  function tempfile_symlink (line 11) | def tempfile_symlink(tmp_path):
  function assert_equal_se (line 20) | def assert_equal_se(is_x, want_x):
  function test (line 27) | def test(tempfile_symlink):
  function test_listxattr_buffer_growth (line 54) | def test_listxattr_buffer_growth(tempfile_symlink):
  function test_getxattr_buffer_growth (line 68) | def test_getxattr_buffer_growth(tempfile_symlink):
  function test_split_lstring (line 83) | def test_split_lstring(lstring, expected):
  function test_xattr_fakeroot_flag (line 87) | def test_xattr_fakeroot_flag():

FILE: src/borg/upgrade.py
  class UpgraderNoOp (line 13) | class UpgraderNoOp:
    method __init__ (line 14) | def __init__(self, *, cache, args):
    method new_archive (line 17) | def new_archive(self, *, archive):
    method upgrade_item (line 20) | def upgrade_item(self, *, item):
    method upgrade_compressed_chunk (line 23) | def upgrade_compressed_chunk(self, meta, data):
    method upgrade_archive_metadata (line 26) | def upgrade_archive_metadata(self, *, metadata):
  class UpgraderFrom12To20 (line 50) | class UpgraderFrom12To20:
    method __init__ (line 53) | def __init__(self, *, cache, args):
    method new_archive (line 57) | def new_archive(self, *, archive):
    method upgrade_item (line 62) | def upgrade_item(self, *, item):
    method upgrade_compressed_chunk (line 117) | def upgrade_compressed_chunk(self, meta, data):
    method upgrade_archive_metadata (line 149) | def upgrade_archive_metadata(self, *, metadata):

FILE: src/borg/version.py
  function parse_version (line 4) | def parse_version(version):
  function format_version (line 36) | def format_version(version):

FILE: src/borg/xattr.py
  function is_enabled (line 42) | def is_enabled(path=None):
  function get_all (line 60) | def get_all(path, follow_symlinks=False):
  function set_all (line 99) | def set_all(path, xattrs, follow_symlinks=False):