dulwich API reference

400 public APIs from dulwich (dulwich/dulwich) — 145 classes, 41 functions, 214 methods. Signatures extracted by static analysis of the actual source.

Repository: dulwich/dulwich

Kind	Count
Classes	145
Functions	41
Methods	214

API list

classcontrib.greenthreads.GreenThreadsMissingObjectFinder

Find the objects missing from another object store.

classcontrib.paramiko_vendor.ParamikoSSHVendor

SSH vendor implementation using paramiko.

classcontrib.requests_vendor.RequestsHttpGitClient

HTTP Git client using the requests library.

funccontrib.requests_vendor.get_session(config:'ConfigFile | None') -> Session

Create a requests session with Git configuration.

classcontrib.swift.PackInfoMissingObjectFinder

Find missing objects required for pack generation.

methodcontrib.swift.PackInfoMissingObjectFinder.next() -> tuple[bytes, int, bytes | None] | None

Get the next missing object.

classcontrib.swift.SwiftException

Exception raised for Swift-related errors.

classcontrib.swift.SwiftInfoRefsContainer

Manage references in info/refs object.

methodcontrib.swift.SwiftInfoRefsContainer.allkeys() -> set[Ref]

Get all reference names.

methodcontrib.swift.SwiftInfoRefsContainer.get_packed_refs() -> dict[Ref, ObjectID]

Get packed references.

methodcontrib.swift.SwiftInfoRefsContainer.get_peeled(name:Ref) -> ObjectID | None

Get peeled version of a reference.

methodcontrib.swift.SwiftInfoRefsContainer.read_loose_ref(name:Ref) -> bytes | None

Read a loose reference.

classcontrib.swift.SwiftObjectStore

A Swift Object Store.

funccontrib.swift.SwiftObjectStore.abort() -> None

Abort the pack operation (no-op).

methodcontrib.swift.SwiftObjectStore.add_object(obj:object) -> None

Add a single object to the store.

methodcontrib.swift.SwiftObjectStore.add_pack() -> tuple[BytesIO, Callable[[], None], Callable[[], None]]

Add a new pack to this object store.

method

contrib.swift.SwiftObjectStore.add_thin_pack(read_all:Callable[[int], bytes], read_some:Callable[[int], bytes]) -> 'SwiftPack'

Read a thin pack.

funccontrib.swift.SwiftObjectStore.commit() -> 'SwiftPack | None'

Commit the pack to Swift storage.

funccontrib.swift.SwiftObjectStore.commit_wrapper() -> None

Wrapper that discards the return value.

methodcontrib.swift.SwiftObjectStore.pack_info_get(sha:ObjectID) -> tuple[Any, ...] | None

Get pack info for a specific SHA.

classcontrib.swift.SwiftPack

A Git pack object.

methodcontrib.swift.SwiftPack.pack_info() -> dict[str, Any] | None

The pack data object being used.

classcontrib.swift.SwiftPackData

The data contained in a packfile.

methodcontrib.swift.SwiftPackData.close() -> None

Close the pack data (no-op for Swift).

methodcontrib.swift.SwiftPackData.get_object_at(offset:int) -> tuple[int, tuple[bytes | int, list[bytes]] | list[bytes]]

Get the object at a specific offset in the pack.

methodcontrib.swift.SwiftPackData.get_stored_checksum() -> bytes

Get the stored checksum for this pack.

classcontrib.swift.SwiftPackReader

A SwiftPackReader that mimic read and sync method.

methodcontrib.swift.SwiftPackReader.read(length:int) -> bytes

Read a specified amount of Bytes form the pack object.

methodcontrib.swift.SwiftPackReader.read_checksum() -> bytes

Read the checksum from the pack.

methodcontrib.swift.SwiftPackReader.seek(offset:int) -> None

Seek to a specified offset.

classcontrib.swift.SwiftRepo

A Git repository backed by Swift object storage.

methodcontrib.swift.SwiftRepo.init_bare(scon:SwiftConnector, conf:ConfigParser) -> 'SwiftRepo'

Create a new bare repository.

classcontrib.swift.SwiftSystemBackend

Backend for serving Git repositories from Swift.

methodcontrib.swift.SwiftSystemBackend.open_repository(path:str) -> 'BackendRepo'

Open a repository at the given path.

funccontrib.swift.cmd_daemon(args:list[str]) -> None

Start a TCP git server for Swift repositories.

funccontrib.swift.cmd_init(args:list[str]) -> None

Initialize a new Git repository in Swift.

funccontrib.swift.load_conf(path:str | None=None, file:str | None=None) -> ConfigParser

Load configuration in global var CONF.

func

contrib.swift.load_pack_info(filename:str, scon:'SwiftConnector | None'=None, file:BinaryIO | None=None) -> dict[str, Any] | None

Load pack info from Swift or file.

funccontrib.swift.main(argv:list[str]=sys.argv) -> None

Main entry point for Swift Git command line interface.

funccontrib.swift.pack_info_create(pack_data:'PackData', pack_index:'PackIndex') -> bytes

Create pack info file contents.

funccontrib.swift.swift_load_pack_index(scon:'SwiftConnector', filename:str, object_format:'ObjectFormat') -> 'PackIndex'

Read a pack index file from Swift.

funcdulwich.aiohttp.server.get_index_file(request:web.Request) -> web.StreamResponse

Handle request for a pack index file.

funcdulwich.aiohttp.server.get_info_packs(request:web.Request) -> web.Response

Handle request for /info/packs.

funcdulwich.aiohttp.server.get_info_refs(request:web.Request) -> web.StreamResponse | web.Response

Handle request for /info/refs.

funcdulwich.aiohttp.server.get_loose_object(request:web.Request) -> web.Response

Handle request for a loose object.

funcdulwich.aiohttp.server.get_pack_file(request:web.Request) -> web.StreamResponse

Handle request for a pack file.

funcdulwich.aiohttp.server.get_text_file(request:web.Request) -> web.StreamResponse

Handle request for a text file.

funcdulwich.aiohttp.server.handle_service_request(request:web.Request) -> web.StreamResponse

Handle a service request endpoint.

funcdulwich.aiohttp.server.main(argv:list[str] | None=None) -> None

Entry point for starting an HTTP git server.

func

dulwich.aiohttp.server.refs_request(repo:Repo, request:web.Request, handlers:dict[bytes, type] | None=None) -> web.StreamResponse | web.Response

Handle a refs request.

funcdulwich.aiohttp.server.send_file(req:web.Request, f:BinaryIO | None, headers:dict[str, str]) -> web.StreamResponse

Send a file-like object to the request output.

classdulwich.am.AmConflict

Raised when a patch fails to apply during am.

classdulwich.am.AmError

Base class for am errors.

classdulwich.am.DiskAmStateManager

Manages git am state on disk in .git/rebase-apply/.

methoddulwich.am.DiskAmStateManager.clean() -> None

Remove the state directory.

methoddulwich.am.DiskAmStateManager.exists() -> bool

Check if am state directory exists.

methoddulwich.am.DiskAmStateManager.get_keep_non_patch() -> bool

Return whether only [PATCH] is stripped from brackets.

methoddulwich.am.DiskAmStateManager.get_keep_subject() -> bool

Return whether subject munging is disabled.

methoddulwich.am.DiskAmStateManager.get_last() -> int

Return the total number of patches.

methoddulwich.am.DiskAmStateManager.get_message_id() -> bool

Return whether Message-ID inclusion is enabled.

methoddulwich.am.DiskAmStateManager.get_next() -> int

Return the 1-based index of the current patch.

methoddulwich.am.DiskAmStateManager.get_orig_head() -> ObjectID

Return the original HEAD sha from before am started.

methoddulwich.am.DiskAmStateManager.get_patch(number:int) -> bytes

Return the raw email bytes for the given patch number.

methoddulwich.am.DiskAmStateManager.get_scissors() -> bool

Return whether scissors line handling is enabled.

methoddulwich.am.DiskAmStateManager.get_strip() -> int

Return the number of path components to strip.

methoddulwich.am.DiskAmStateManager.get_three_way() -> bool

Return whether three-way merge fallback is enabled.

methoddulwich.am.DiskAmStateManager.load_author_info() -> tuple[str, str, str | None]

Load saved author metadata for the current patch.

methoddulwich.am.DiskAmStateManager.load_message() -> bytes

Load the saved commit message for the current patch.

methoddulwich.am.DiskAmStateManager.save_author_info(name:str, email_addr:str, date:str | None) -> None

Save author metadata for the current patch.

methoddulwich.am.DiskAmStateManager.save_message(message:bytes) -> None

Save the commit message for the current patch.

methoddulwich.am.DiskAmStateManager.set_next(value:int) -> None

Set the current patch index.

funcdulwich.am.am_abort(r:'Repo', *config:'Config | None'=None) -> None

Abort the current am operation and restore the original state.

funcdulwich.am.am_quit(r:'Repo') -> None

Quit the current am operation without reverting changes.

funcdulwich.approxidate.parse_approxidate(time_spec:str | bytes) -> int

Parse a Git approxidate specification and return a Unix timestamp.

funcdulwich.approxidate.parse_relative_time(time_str:str) -> int

Parse a relative time string like '2 weeks ago' into seconds.

classdulwich.archive.ChunkedBytesIO

Turn a list of bytestrings into a file-like object.

methoddulwich.archive.ChunkedBytesIO.read(maxbytes:int | None=None) -> bytes

Read bytes from the chunked stream.

classdulwich.attrs.GitAttributes

A collection of gitattributes patterns that can match paths.

methoddulwich.attrs.GitAttributes.add_patterns(patterns:Sequence[tuple[Pattern, Mapping[bytes, AttributeValue]]]) -> None

Add patterns to the collection.

methoddulwich.attrs.GitAttributes.from_file(filename:str | bytes) -> 'GitAttributes'

Create GitAttributes from a gitattributes file.

methoddulwich.attrs.GitAttributes.from_path(path:str | bytes) -> 'GitAttributes'

Create GitAttributes from .gitattributes in a directory.

methoddulwich.attrs.GitAttributes.match_path(path:bytes) -> dict[bytes, AttributeValue]

Get attributes for a path by matching against patterns.

methoddulwich.attrs.GitAttributes.remove_pattern(pattern:bytes) -> None

Remove all attributes for a pattern.

methoddulwich.attrs.GitAttributes.set_attribute(pattern:bytes, name:bytes, value:AttributeValue) -> None

Set an attribute for a pattern.

methoddulwich.attrs.GitAttributes.to_bytes() -> bytes

Convert GitAttributes to bytes format suitable for writing to file.

methoddulwich.attrs.GitAttributes.write_to_file(filename:str | bytes) -> None

Write GitAttributes to a file.

classdulwich.attrs.Pattern

A single gitattributes pattern.

methoddulwich.attrs.Pattern.match(path:bytes) -> bool

Check if path matches this pattern.

funcdulwich.attrs.parse_git_attributes(f:IO[bytes]) -> Generator[tuple[bytes, Mapping[bytes, AttributeValue]], None, None]

Parse a Git attributes string.

funcdulwich.attrs.parse_gitattributes_file(filename:str | bytes) -> list[tuple[Pattern, Mapping[bytes, AttributeValue]]]

Parse a gitattributes file and return compiled patterns.

funcdulwich.attrs.read_gitattributes(path:str | bytes) -> list[tuple[Pattern, Mapping[bytes, AttributeValue]]]

Read .gitattributes from a directory.

classdulwich.bisect.BisectState

Manages the state of a bisect session.

methoddulwich.bisect.BisectState.get_log() -> str

Get the bisect log.

methoddulwich.bisect.BisectState.is_active() -> bool

Check if a bisect session is active.

methoddulwich.bisect.BisectState.mark_bad(rev:ObjectID | None=None) -> ObjectID | None

Mark a commit as bad.

methoddulwich.bisect.BisectState.mark_good(rev:ObjectID | None=None) -> ObjectID | None

Mark a commit as good.

methoddulwich.bisect.BisectState.replay(log_content:str) -> None

Replay a bisect log.

methoddulwich.bisect.BisectState.reset(commit:ObjectID | None=None) -> None

Reset bisect state and return to original branch/commit.

methoddulwich.bisect.BisectState.skip(revs:Sequence[ObjectID] | None=None) -> ObjectID | None

Skip one or more commits.

method

dulwich.bisect.BisectState.start(bad:ObjectID | None=None, good:Sequence[ObjectID] | None=None, paths:Sequence[bytes] | None=None, no_checkout:bool=False, term_bad:str='bad', term_good:str='good') -> None

Start a new bisect session.

classdulwich.bitmap.BitmapEntry

A single bitmap entry for a commit.

classdulwich.bitmap.EWAHBitmap

EWAH (Enhanced Word-Aligned Hybrid) compressed bitmap.

methoddulwich.bitmap.EWAHBitmap.add(bit:int) -> None

Set a bit.

methoddulwich.bitmap.EWAHBitmap.encode() -> bytes

Encode bitmap to EWAH compressed format.

classdulwich.bitmap.PackBitmap

A pack bitmap index.

methoddulwich.bitmap.PackBitmap.get_bitmap(commit_sha:bytes) -> EWAHBitmap | None

Get the bitmap for a commit.

methoddulwich.bitmap.PackBitmap.has_commit(commit_sha:bytes) -> bool

Check if a commit has a bitmap.

methoddulwich.bitmap.PackBitmap.iter_commits() -> Iterator[bytes]

Iterate over all commits with bitmaps.

func

dulwich.bitmap.apply_xor_compression(bitmaps:list[tuple[ObjectID, EWAHBitmap]], max_xor_offset:int=MAX_XOR_OFFSET) -> list[tuple[ObjectID, EWAHBitmap, int]]

Apply XOR compression to bitmaps.

func

dulwich.bitmap.bitmap_to_object_shas(bitmap:EWAHBitmap, pack_index:'PackIndex', type_filter:EWAHBitmap | None=None) -> set[ObjectID]

Convert a bitmap to a set of object SHAs.

funcdulwich.bitmap.build_name_hash_cache(sha_to_pos:dict['RawObjectID', int], object_store:'BaseObjectStore') -> list[int]

Build name-hash cache for all objects in a pack.

func

dulwich.bitmap.build_reachability_bitmap(commit_sha:ObjectID, sha_to_pos:dict[RawObjectID, int], object_store:'BaseObjectStore') -> EWAHBitmap

Build a reachability bitmap for a commit.

func

dulwich.bitmap.read_bitmap(filename:str | os.PathLike[str], pack_index:'PackIndex | None'=None, pack_checksum:bytes | None=None) -> PackBitmap

Read a bitmap index file.

func

dulwich.bitmap.read_bitmap_file(f:IO[bytes], pack_index:'PackIndex | None'=None, pack_checksum:bytes | None=None) -> PackBitmap

Read bitmap data from a file object.

func

dulwich.bitmap.select_bitmap_commits(refs:dict['Ref', ObjectID], object_store:'BaseObjectStore', commit_interval:int=DEFAULT_COMMIT_INTERVAL) -> list[ObjectID]

Select commits for bitmap generation.

funcdulwich.bitmap.write_bitmap(filename:str | os.PathLike[str], bitmap:PackBitmap) -> None

Write a bitmap index file.

funcdulwich.bitmap.write_bitmap_file(f:IO[bytes], bitmap:PackBitmap) -> None

Write bitmap data to a file object.

classdulwich.bundle.Bundle

Git bundle object representation.

methoddulwich.bundle.Bundle.close() -> None

Close any open resources in this bundle.

classdulwich.bundle.PackDataLike

Protocol for objects that behave like PackData.

methoddulwich.bundle.PackDataLike.close() -> None

Close any open resources.

methoddulwich.bundle.PackDataLike.iter_unpacked() -> Iterator[UnpackedObject]

Iterate over unpacked objects in the pack.

funcdulwich.bundle.read_bundle(f:BinaryIO) -> Bundle

Read a bundle file.

funcdulwich.bundle.write_bundle(f:BinaryIO, bundle:Bundle) -> None

Write a bundle to a file.

classdulwich.bundle_uri.BundleListEntry

Represents a single bundle in a bundle list.

classdulwich.bundle_uri.BundleURIError

Error related to bundle URI operations.

func

dulwich.bundle_uri.fetch_bundle_uri(uri:str, progress:Callable[[bytes], None] | None=None, timeout:float | None=None) -> tuple['Bundle | None', 'BundleList | None']

Fetch content from a bundle URI.

funcdulwich.bundle_uri.parse_bundle_list(data:bytes, base_uri:str | None=None) -> BundleList

Parse a bundle list from Git config format.

classdulwich.cli.Command

A Dulwich subcommand.

methoddulwich.cli.Command.run(args:Sequence[str]) -> int | None

Run the command.

classdulwich.cli.CommitMessageError

Raised when there's an issue with the commit message.

classdulwich.cli.Pager

File-like object that pages output through external pager programs.

methoddulwich.cli.Pager.buffer() -> BinaryIO

Return the underlying binary buffer.

methoddulwich.cli.Pager.close() -> None

Close the pager.

methoddulwich.cli.Pager.closed() -> bool

Return whether the pager is closed.

methoddulwich.cli.Pager.encoding() -> str

Return the encoding used.

methoddulwich.cli.Pager.errors() -> str | None

Return the error handling scheme.

methoddulwich.cli.Pager.fileno() -> int

Return the file descriptor (not supported).

methoddulwich.cli.Pager.flush() -> None

Flush the pager.

methoddulwich.cli.Pager.isatty() -> bool

Return whether the pager is a TTY.

methoddulwich.cli.Pager.line_buffering() -> bool

Return whether line buffering is enabled.

methoddulwich.cli.Pager.mode() -> str

Return the mode.

methoddulwich.cli.Pager.name() -> str

Return the name.

methoddulwich.cli.Pager.newlines() -> str | tuple[str, ...] | None

Return the newlines mode.

methoddulwich.cli.Pager.read(size:int=-1) -> str

Read from the pager (not supported).

methoddulwich.cli.Pager.readable() -> bool

Return whether the pager is readable (it's not).

methoddulwich.cli.Pager.readline(size:int=-1) -> str

Read a line from the pager (not supported).

methoddulwich.cli.Pager.readlines(hint:int=-1) -> list[str]

Read lines from the pager (not supported).

methoddulwich.cli.Pager.seek(offset:int, whence:int=0) -> int

Seek in the pager (not supported).

methoddulwich.cli.Pager.seekable() -> bool

Return whether the pager is seekable (it's not).

methoddulwich.cli.Pager.tell() -> int

Return the current position (not supported).

methoddulwich.cli.Pager.truncate(size:int | None=None) -> int

Truncate the pager (not supported).

methoddulwich.cli.Pager.writable() -> bool

Return whether the pager is writable.

methoddulwich.cli.Pager.write(text:str) -> int

Write text to the pager.

methoddulwich.cli.Pager.writelines(lines:Iterable[str]) -> None

Write a list of lines to the pager.

classdulwich.cli.PagerBuffer

Binary buffer wrapper for Pager to mimic sys.stdout.buffer.

methoddulwich.cli.PagerBuffer.close() -> None

Close the pager.

methoddulwich.cli.PagerBuffer.closed() -> bool

Return whether the buffer is closed.

methoddulwich.cli.PagerBuffer.fileno() -> int

Return the file descriptor (not supported).

methoddulwich.cli.PagerBuffer.flush() -> None

Flush the pager.

methoddulwich.cli.PagerBuffer.isatty() -> bool

Return whether the buffer is a TTY.

methoddulwich.cli.PagerBuffer.mode() -> str

Return the mode.

methoddulwich.cli.PagerBuffer.name() -> str

Return the name.

methoddulwich.cli.PagerBuffer.read(size:int=-1) -> bytes

Read from the buffer (not supported).

methoddulwich.cli.PagerBuffer.read1(size:int=-1) -> bytes

Read from the buffer (not supported).

methoddulwich.cli.PagerBuffer.readable() -> bool

Return whether the buffer is readable (it's not).

methoddulwich.cli.PagerBuffer.readinto(b:bytearray) -> int

Read into buffer (not supported).

methoddulwich.cli.PagerBuffer.readinto1(b:bytearray) -> int

Read into buffer (not supported).

methoddulwich.cli.PagerBuffer.readline(size:int=-1) -> bytes

Read a line from the buffer (not supported).

methoddulwich.cli.PagerBuffer.readlines(hint:int=-1) -> list[bytes]

Read lines from the buffer (not supported).

methoddulwich.cli.PagerBuffer.seek(offset:int, whence:int=0) -> int

Seek in the buffer (not supported).

methoddulwich.cli.PagerBuffer.seekable() -> bool

Return whether the buffer is seekable (it's not).

methoddulwich.cli.PagerBuffer.tell() -> int

Return the current position (not supported).

methoddulwich.cli.PagerBuffer.truncate(size:int | None=None) -> int

Truncate the buffer (not supported).

methoddulwich.cli.PagerBuffer.writable() -> bool

Return whether the buffer is writable.

methoddulwich.cli.PagerBuffer.write(data:bytes | bytearray | memoryview) -> int

Write bytes to pager.

methoddulwich.cli.PagerBuffer.writelines(lines:Iterable[bytes | bytearray | memoryview]) -> None

Write multiple lines to pager.

classdulwich.cli.SuperCommand

Base class for commands that have subcommands.

methoddulwich.cli.SuperCommand.run(args:Sequence[str]) -> int | None

Execute the subcommand command.

classdulwich.cli.cmd_add

Add file contents to the index.

methoddulwich.cli.cmd_add.run(argv:Sequence[str]) -> None

Execute the add command.

classdulwich.cli.cmd_am

Apply patches from mailbox-style email messages.

classdulwich.cli.cmd_annotate

Annotate each line in a file with commit information.

methoddulwich.cli.cmd_annotate.run(argv:Sequence[str]) -> None

Execute the annotate command.

classdulwich.cli.cmd_apply

Apply a patch to files and/or to the index.

methoddulwich.cli.cmd_apply.run(args:Sequence[str]) -> None

Execute the apply command.

classdulwich.cli.cmd_archive

Create an archive of files from a named tree.

methoddulwich.cli.cmd_archive.run(args:Sequence[str]) -> None

Execute the archive command.

classdulwich.cli.cmd_bisect

Use binary search to find the commit that introduced a bug.

methoddulwich.cli.cmd_bisect.run(args:Sequence[str]) -> int | None

Execute the bisect command.

classdulwich.cli.cmd_blame

Show what revision and author last modified each line of a file.

methoddulwich.cli.cmd_blame.run(argv:Sequence[str]) -> None

Execute the blame command.

classdulwich.cli.cmd_branch

List, create, or delete branches.

methoddulwich.cli.cmd_branch.run(args:Sequence[str]) -> int | None

Execute the branch command.

classdulwich.cli.cmd_bundle

Create, unpack, and manipulate bundle files.

methoddulwich.cli.cmd_bundle.run(args:Sequence[str]) -> int

Execute the bundle command.

classdulwich.cli.cmd_check_ignore

Check whether files are excluded by gitignore.

methoddulwich.cli.cmd_check_ignore.run(args:Sequence[str]) -> int

Execute the check-ignore command.

classdulwich.cli.cmd_check_mailmap

Show canonical names and email addresses of contacts.

methoddulwich.cli.cmd_check_mailmap.run(args:Sequence[str]) -> None

Execute the check-mailmap command.

classdulwich.cli.cmd_checkout

Switch branches or restore working tree files.

methoddulwich.cli.cmd_checkout.run(args:Sequence[str]) -> int | None

Execute the checkout command.

classdulwich.cli.cmd_cherry

Find commits not merged upstream.

methoddulwich.cli.cmd_cherry.run(args:Sequence[str]) -> int | None

Execute the cherry command.

classdulwich.cli.cmd_cherry_pick

Apply the changes introduced by some existing commits.

methoddulwich.cli.cmd_cherry_pick.run(args:Sequence[str]) -> int | None

Execute the cherry-pick command.

classdulwich.cli.cmd_clean

Remove untracked files from the working tree.

methoddulwich.cli.cmd_clean.run(args:Sequence[str]) -> int

Execute the clean command.

classdulwich.cli.cmd_clone

Clone a repository into a new directory.

methoddulwich.cli.cmd_clone.run(args:Sequence[str]) -> int | None

Execute the clone command.

classdulwich.cli.cmd_column

Display data in columns.

methoddulwich.cli.cmd_column.run(args:Sequence[str]) -> None

Execute the column command.

classdulwich.cli.cmd_commit

Record changes to the repository.

methoddulwich.cli.cmd_commit.run(args:Sequence[str]) -> int | None

Execute the commit command.

classdulwich.cli.cmd_commit_tree

Create a new commit object from a tree.

methoddulwich.cli.cmd_commit_tree.run(args:Sequence[str]) -> None

Execute the commit-tree command.

classdulwich.cli.cmd_config

Get and set repository or global options.

methoddulwich.cli.cmd_config.run(args:Sequence[str]) -> int | None

Execute the config command.

classdulwich.cli.cmd_count_objects

Count unpacked number of objects and their disk consumption.

methoddulwich.cli.cmd_count_objects.run(args:Sequence[str]) -> None

Execute the count-objects command.

classdulwich.cli.cmd_daemon

Run a simple Git protocol server.

methoddulwich.cli.cmd_daemon.run(args:Sequence[str]) -> None

Execute the daemon command.

classdulwich.cli.cmd_describe

Give an object a human readable name based on an available ref.

methoddulwich.cli.cmd_describe.run(args:Sequence[str]) -> None

Execute the describe command.

classdulwich.cli.cmd_diagnose

Display diagnostic information about the Python environment.

methoddulwich.cli.cmd_diagnose.run(args:Sequence[str]) -> None

Execute the diagnose command.

classdulwich.cli.cmd_diff

Show changes between commits, commit and working tree, etc.

methoddulwich.cli.cmd_diff.run(args:Sequence[str]) -> None

Execute the diff command.

classdulwich.cli.cmd_diff_tree

Compare the content and mode of trees.

methoddulwich.cli.cmd_diff_tree.run(args:Sequence[str]) -> None

Execute the diff-tree command.

classdulwich.cli.cmd_dump_index

Show information about a pack index file.

methoddulwich.cli.cmd_dump_index.run(args:Sequence[str]) -> None

Execute the dump-index command.

classdulwich.cli.cmd_dump_pack

Dump the contents of a pack file for debugging.

methoddulwich.cli.cmd_dump_pack.run(args:Sequence[str]) -> None

Execute the dump-pack command.

classdulwich.cli.cmd_fetch

Download objects and refs from another repository.

methoddulwich.cli.cmd_fetch.run(args:Sequence[str]) -> None

Execute the fetch command.

classdulwich.cli.cmd_fetch_pack

Receive missing objects from another repository.

methoddulwich.cli.cmd_fetch_pack.run(argv:Sequence[str]) -> None

Execute the fetch-pack command.

classdulwich.cli.cmd_filter_branch

Rewrite branches.

methoddulwich.cli.cmd_filter_branch.run(args:Sequence[str]) -> int | None

Execute the filter-branch command.

classdulwich.cli.cmd_for_each_ref

Output information on each ref.

methoddulwich.cli.cmd_for_each_ref.run(args:Sequence[str]) -> None

Execute the for-each-ref command.

classdulwich.cli.cmd_format_patch

Prepare patches for e-mail submission.

methoddulwich.cli.cmd_format_patch.run(args:Sequence[str]) -> None

Execute the format-patch command.

classdulwich.cli.cmd_fsck

Verify the connectivity and validity of objects in the database.

methoddulwich.cli.cmd_fsck.run(args:Sequence[str]) -> None

Execute the fsck command.

classdulwich.cli.cmd_gc

Cleanup unnecessary files and optimize the local repository.

methoddulwich.cli.cmd_gc.run(args:Sequence[str]) -> int | None

Execute the gc command.

classdulwich.cli.cmd_grep

Search for patterns in tracked files.

methoddulwich.cli.cmd_grep.run(args:Sequence[str]) -> None

Execute the grep command.

classdulwich.cli.cmd_hash_object

Compute object ID and optionally store in repository.

methoddulwich.cli.cmd_hash_object.run(args:Sequence[str]) -> int

Execute the hash-object command.

classdulwich.cli.cmd_help

Display help information about git.

methoddulwich.cli.cmd_help.run(args:Sequence[str]) -> None

Execute the help command.

classdulwich.cli.cmd_init

Create an empty Git repository or reinitialize an existing one.

methoddulwich.cli.cmd_init.run(args:Sequence[str]) -> None

Execute the init command.

classdulwich.cli.cmd_interpret_trailers

Add or parse structured information in commit messages.

methoddulwich.cli.cmd_interpret_trailers.run(args:Sequence[str]) -> None

Execute the interpret-trailers command.

classdulwich.cli.cmd_lfs

Git Large File Storage management.

methoddulwich.cli.cmd_lfs.run(argv:Sequence[str]) -> None

Execute the lfs command.

classdulwich.cli.cmd_log

Show commit logs.

methoddulwich.cli.cmd_log.run(args:Sequence[str]) -> None

Execute the log command.

classdulwich.cli.cmd_ls_files

Show information about files in the index and working tree.

methoddulwich.cli.cmd_ls_files.run(args:Sequence[str]) -> None

Execute the ls-files command.

classdulwich.cli.cmd_ls_remote

List references in a remote repository.

methoddulwich.cli.cmd_ls_remote.run(args:Sequence[str]) -> None

Execute the ls-remote command.

classdulwich.cli.cmd_ls_tree

List the contents of a tree object.

methoddulwich.cli.cmd_ls_tree.run(args:Sequence[str]) -> None

Execute the ls-tree command.

classdulwich.cli.cmd_mailinfo

Extract patch information from an email message.

methoddulwich.cli.cmd_mailinfo.run(args:Sequence[str]) -> None

Execute the mailinfo command.

classdulwich.cli.cmd_mailsplit

Split mbox or Maildir into individual message files.

methoddulwich.cli.cmd_mailsplit.run(args:Sequence[str]) -> None

Execute the mailsplit command.

classdulwich.cli.cmd_maintenance

Run tasks to optimize Git repository data.

methoddulwich.cli.cmd_maintenance.run(args:Sequence[str]) -> int | None

Execute the maintenance command.

classdulwich.cli.cmd_merge

Join two or more development histories together.

methoddulwich.cli.cmd_merge.run(args:Sequence[str]) -> int | None

Execute the merge command.

classdulwich.cli.cmd_merge_base

Find the best common ancestor between commits.

methoddulwich.cli.cmd_merge_base.run(args:Sequence[str]) -> int | None

Execute the merge-base command.

classdulwich.cli.cmd_merge_tree

Show three-way merge without touching index.

methoddulwich.cli.cmd_merge_tree.run(args:Sequence[str]) -> int | None

Execute the merge-tree command.

classdulwich.cli.cmd_mktag

Create a tag object from raw tag data.

methoddulwich.cli.cmd_mktag.run(args:Sequence[str]) -> int

Execute the mktag command.

classdulwich.cli.cmd_mv

Move or rename a file, a directory, or a symlink.

methoddulwich.cli.cmd_mv.run(argv:Sequence[str]) -> None

Execute the mv command.

classdulwich.cli.cmd_notes

Add or inspect object notes.

classdulwich.cli.cmd_notes_add

Add notes to a commit.

methoddulwich.cli.cmd_notes_add.run(args:Sequence[str]) -> None

Execute the notes-add command.

classdulwich.cli.cmd_notes_list

List all note objects.

methoddulwich.cli.cmd_notes_list.run(args:Sequence[str]) -> None

Execute the notes-list command.

classdulwich.cli.cmd_notes_remove

Remove notes for a commit.

methoddulwich.cli.cmd_notes_remove.run(args:Sequence[str]) -> None

Execute the notes-remove command.

classdulwich.cli.cmd_notes_show

Show notes for a commit.

methoddulwich.cli.cmd_notes_show.run(args:Sequence[str]) -> None

Execute the notes-show command.

classdulwich.cli.cmd_pack_objects

Create a packed archive of objects.

methoddulwich.cli.cmd_pack_objects.run(args:Sequence[str]) -> None

Execute the pack-objects command.

classdulwich.cli.cmd_pack_refs

Pack heads and tags for efficient repository access.

methoddulwich.cli.cmd_pack_refs.run(argv:Sequence[str]) -> None

Execute the pack-refs command.

classdulwich.cli.cmd_prune

Prune all unreachable objects from the object database.

methoddulwich.cli.cmd_prune.run(args:Sequence[str]) -> int | None

Execute the prune command.

methoddulwich.cli.cmd_pull.run(args:Sequence[str]) -> int | None

Execute the pull command.

classdulwich.cli.cmd_push

Update remote refs along with associated objects.

methoddulwich.cli.cmd_push.run(argv:Sequence[str]) -> int | None

Execute the push command.

classdulwich.cli.cmd_range_diff

Compare two commit ranges.

methoddulwich.cli.cmd_range_diff.run(args:Sequence[str]) -> int | None

Execute the range-diff command.

classdulwich.cli.cmd_rebase

Reapply commits on top of another base tip.

methoddulwich.cli.cmd_rebase.run(args:Sequence[str]) -> int

Execute the rebase command.

classdulwich.cli.cmd_receive_pack

Receive what is pushed into the repository.

methoddulwich.cli.cmd_receive_pack.run(args:Sequence[str]) -> None

Execute the receive-pack command.

classdulwich.cli.cmd_reflog

Manage reflog information.

methoddulwich.cli.cmd_reflog.run(args:Sequence[str]) -> None

Execute the reflog command.

classdulwich.cli.cmd_remote

Manage set of tracked repositories.

classdulwich.cli.cmd_remote_add

Add a remote repository.

methoddulwich.cli.cmd_remote_add.run(args:Sequence[str]) -> None

Execute the remote-add command.

classdulwich.cli.cmd_repack

Pack unpacked objects in a repository.

methoddulwich.cli.cmd_repack.run(args:Sequence[str]) -> None

Execute the repack command.

classdulwich.cli.cmd_replace

Create, list, and delete replacement refs.

methoddulwich.cli.cmd_replace.run(args:Sequence[str]) -> int | None

Execute the replace command.

classdulwich.cli.cmd_replace_delete

Delete a replacement ref.

methoddulwich.cli.cmd_replace_delete.run(args:Sequence[str]) -> int | None

Execute the replace-delete command.

classdulwich.cli.cmd_replace_list

List all replacement refs.

methoddulwich.cli.cmd_replace_list.run(args:Sequence[str]) -> None

Execute the replace-list command.

classdulwich.cli.cmd_request_pull

Generate a summary of pending changes.

methoddulwich.cli.cmd_request_pull.run(args:Sequence[str]) -> int | None

Execute the request-pull command.

classdulwich.cli.cmd_rerere

Record and reuse recorded conflict resolutions.

methoddulwich.cli.cmd_rerere.run(args:Sequence[str]) -> None

Execute the rerere command.

classdulwich.cli.cmd_reset

Reset current HEAD to the specified state.

methoddulwich.cli.cmd_reset.run(args:Sequence[str]) -> int | None

Execute the reset command.

classdulwich.cli.cmd_restore

Restore working tree files.

methoddulwich.cli.cmd_restore.run(args:Sequence[str]) -> int | None

Execute the restore command.

classdulwich.cli.cmd_rev_list

List commit objects in reverse chronological order.

methoddulwich.cli.cmd_rev_list.run(args:Sequence[str]) -> None

Execute the rev-list command.

classdulwich.cli.cmd_rev_parse

Parse revision and other objects.

methoddulwich.cli.cmd_rev_parse.run(args:Sequence[str]) -> int

Execute the rev-parse command.

classdulwich.cli.cmd_revert

Revert some existing commits.

methoddulwich.cli.cmd_revert.run(args:Sequence[str]) -> int | None

Execute the revert command.

classdulwich.cli.cmd_rm

Remove files from the working tree and from the index.

methoddulwich.cli.cmd_rm.run(argv:Sequence[str]) -> None

Execute the rm command.

classdulwich.cli.cmd_shortlog

Show a shortlog of commits by author.

methoddulwich.cli.cmd_shortlog.run(args:Sequence[str]) -> None

Execute the shortlog command with the given CLI arguments.

classdulwich.cli.cmd_show

Show various types of objects.

methoddulwich.cli.cmd_show.run(argv:Sequence[str]) -> None

Execute the show command.

classdulwich.cli.cmd_show_branch

Show branches and their commits.

methoddulwich.cli.cmd_show_branch.run(args:Sequence[str]) -> int | None

Execute the show-branch command.

classdulwich.cli.cmd_show_index

Show packed archive index.

methoddulwich.cli.cmd_show_index.run(args:Sequence[str]) -> int

Execute the show-index command.

classdulwich.cli.cmd_show_ref

List references in a local repository.

methoddulwich.cli.cmd_show_ref.run(args:Sequence[str]) -> int | None

Execute the show-ref command.

classdulwich.cli.cmd_sparse_checkout

Manage sparse checkout.

classdulwich.cli.cmd_sparse_checkout_add

Add directories to sparse checkout.

methoddulwich.cli.cmd_sparse_checkout_add.run(args:Sequence[str]) -> int

Execute the sparse-checkout add command.

classdulwich.cli.cmd_sparse_checkout_disable

Disable sparse checkout.

methoddulwich.cli.cmd_sparse_checkout_disable.run(args:Sequence[str]) -> int

Execute the sparse-checkout disable command.

classdulwich.cli.cmd_sparse_checkout_init

Initialize sparse checkout in cone mode.

methoddulwich.cli.cmd_sparse_checkout_init.run(args:Sequence[str]) -> int

Execute the sparse-checkout init command.

classdulwich.cli.cmd_sparse_checkout_list

List sparse checkout patterns.

methoddulwich.cli.cmd_sparse_checkout_list.run(args:Sequence[str]) -> int

Execute the sparse-checkout list command.

classdulwich.cli.cmd_sparse_checkout_set

Set sparse checkout directories.

methoddulwich.cli.cmd_sparse_checkout_set.run(args:Sequence[str]) -> int

Execute the sparse-checkout set command.

classdulwich.cli.cmd_stash

Stash the changes in a dirty working directory away.

classdulwich.cli.cmd_stash_list

List stash entries.

methoddulwich.cli.cmd_stash_list.run(args:Sequence[str]) -> None

Execute the stash-list command.

classdulwich.cli.cmd_stash_pop

Apply a stash and remove it from the stash list.

methoddulwich.cli.cmd_stash_pop.run(args:Sequence[str]) -> int | None

Execute the stash-pop command.

classdulwich.cli.cmd_stash_push

Save your local modifications to a new stash.

methoddulwich.cli.cmd_stash_push.run(args:Sequence[str]) -> None

Execute the stash-push command.

classdulwich.cli.cmd_status

Show the working tree status.

methoddulwich.cli.cmd_status.run(args:Sequence[str]) -> None

Execute the status command.

classdulwich.cli.cmd_stripspace

Remove unnecessary whitespace from text.

methoddulwich.cli.cmd_stripspace.run(args:Sequence[str]) -> None

Execute the stripspace command.

classdulwich.cli.cmd_submodule

Initialize, update or inspect submodules.

classdulwich.cli.cmd_submodule_add

Add a submodule.

methoddulwich.cli.cmd_submodule_add.run(argv:Sequence[str]) -> None

Execute the submodule-add command.

classdulwich.cli.cmd_submodule_init

Initialize submodules.

methoddulwich.cli.cmd_submodule_init.run(argv:Sequence[str]) -> None

Execute the submodule-init command.

classdulwich.cli.cmd_submodule_list

List submodules.

methoddulwich.cli.cmd_submodule_list.run(argv:Sequence[str]) -> None

Execute the submodule-list command.

classdulwich.cli.cmd_submodule_update

Update submodules.

methoddulwich.cli.cmd_submodule_update.run(argv:Sequence[str]) -> None

Execute the submodule-update command.

classdulwich.cli.cmd_subtree

Manage subtrees within a repository.

classdulwich.cli.cmd_subtree_add

Add a subtree.

methoddulwich.cli.cmd_subtree_add.run(argv:Sequence[str]) -> None

Execute the subtree-add command.

classdulwich.cli.cmd_subtree_merge

Merge changes into a subtree.

methoddulwich.cli.cmd_subtree_merge.run(argv:Sequence[str]) -> None

Execute the subtree-merge command.

classdulwich.cli.cmd_subtree_pull

Pull changes from a remote repository into a subtree.

methoddulwich.cli.cmd_subtree_pull.run(argv:Sequence[str]) -> None

Execute the subtree-pull command.

classdulwich.cli.cmd_subtree_push

Push a subtree to a remote repository.

methoddulwich.cli.cmd_subtree_push.run(argv:Sequence[str]) -> None

Execute the subtree-push command.

classdulwich.cli.cmd_subtree_split

Split a subtree into a separate branch.

methoddulwich.cli.cmd_subtree_split.run(argv:Sequence[str]) -> None

Execute the subtree-split command.

classdulwich.cli.cmd_switch

Switch branches.

methoddulwich.cli.cmd_switch.run(args:Sequence[str]) -> int | None

Execute the switch command.

classdulwich.cli.cmd_symbolic_ref

Read, modify and delete symbolic refs.

methoddulwich.cli.cmd_symbolic_ref.run(args:Sequence[str]) -> int | None

Execute the symbolic-ref command.

classdulwich.cli.cmd_tag

Create, list, delete or verify a tag object.

methoddulwich.cli.cmd_tag.run(args:Sequence[str]) -> None

Execute the tag command.

classdulwich.cli.cmd_unpack_objects

Unpack objects from a packed archive.

methoddulwich.cli.cmd_unpack_objects.run(args:Sequence[str]) -> None

Execute the unpack-objects command.

classdulwich.cli.cmd_update_ref

Update the object name stored in a ref safely.

methoddulwich.cli.cmd_update_ref.run(args:Sequence[str]) -> int

Execute the update-ref command.

classdulwich.cli.cmd_update_server_info

Update auxiliary info file to help dumb servers.

About this data

These signatures were extracted from the public source of dulwich/dulwich using Python's ast module. Argument names, default values, type annotations and return types are taken verbatim from the code. Implementation bodies are never stored. See how it works for details.

Back to all 805 libraries