dulwich.client.TraditionalGitClient

class documentation

class TraditionalGitClient(GitClient):

Known subclasses: dulwich.client.SSHGitClient, dulwich.client.SubprocessGitClient, dulwich.client.TCPGitClient

Constructor: TraditionalGitClient(path_encoding, thin_packs, report_activity, quiet, ...)

Traditional Git client.

Method	`__init__`	Initialize a TraditionalGitClient.
Method	`archive`	Request an archive of a specific commit.
Method	`fetch_pack`	Retrieve a pack from a git smart server.
Method	`get_refs`	Retrieve the current refs from a git smart server.
Method	`send_pack`	Upload a pack to a remote repository.
Constant	`DEFAULT_ENCODING`	Undocumented
Instance Variable	`protocol_version`	Undocumented
Method	`_connect`	Create a connection to the server.
Instance Variable	`_remote_path_encoding`	Undocumented
Instance Variable	`_report_status_parser`	Undocumented

Inherited from GitClient:

Class Method	`from_parsedurl`	Create an instance of this client from a urlparse.parsed object.
Method	`clone`	Clone a repository.
Method	`close`	Close the client and release any resources.
Method	`fetch`	Fetch into a target repository.
Method	`fetch_with_bundle_uri`	Fetch into a target repository, using bundle URIs for bootstrap.
Method	`get_url`	Retrieves full url to given path.
Static Method	`_should_send_pack`	Undocumented
Static Method	`_warn_filter_objects`	Undocumented
Method	`_handle_receive_pack_tail`	Handle the tail of a 'git-receive-pack' request.
Method	`_negotiate_receive_pack_capabilities`	Undocumented
Method	`_negotiate_upload_pack_capabilities`	Undocumented
Instance Variable	`_fetch_capabilities`	Undocumented
Instance Variable	`_report_activity`	Undocumented
Instance Variable	`_send_capabilities`	Undocumented

def __init__(self, path_encoding: str = DEFAULT_ENCODING, thin_packs: bool = True, report_activity: Callable[[int, str], None] | None = None, quiet: bool = False, include_tags: bool = False): ¶

overrides dulwich.client.GitClient.__init__

overridden in dulwich.client.SSHGitClient, dulwich.client.TCPGitClient

Initialize a TraditionalGitClient.

Parameters
path_encoding:`str`	Encoding for paths (default: utf-8)
thin_packs:`bool`	Whether or not thin packs should be retrieved
report_activity:`Callable[[int, str], None] \| None`	Optional callback for reporting transport activity
quiet:`bool`	Whether to suppress progress output
include_tags:`bool`	Whether to include tags

def archive(self, path: bytes, committish: bytes, write_data: Callable[[bytes], None], progress: Callable[[bytes], None] | None = None, write_error: Callable[[bytes], None] | None = None, format: bytes | None = None, subdirs: Sequence[bytes] | None = None, prefix: bytes | None = None): ¶

overrides dulwich.client.GitClient.archive

Request an archive of a specific commit.

Parameters
path:`bytes`	Repository path
committish:`bytes`	Commit ID or ref to archive
write_data:`Callable[[bytes], None]`	Function to write archive data
progress:`Callable[[bytes], None] \| None`	Optional progress callback
write_error:`Callable[[bytes], None] \| None`	Optional error callback
format:`bytes \| None`	Optional archive format
subdirs:`Sequence[bytes] \| None`	Optional subdirectories to include
prefix:`bytes \| None`	Optional prefix for archived files

def fetch_pack(self, path: bytes | str, determine_wants: DetermineWantsFunc, graph_walker: GraphWalker, pack_data: Callable[[bytes], int], progress: Callable[[bytes], None] | None = None, depth: int | None = None, ref_prefix: Sequence[bytes] | None = None, filter_spec: bytes | None = None, protocol_version: int | None = None, shallow_since: str | None = None, shallow_exclude: list[str] | None = None) -> FetchPackResult: ¶

overrides dulwich.client.GitClient.fetch_pack

Retrieve a pack from a git smart server.

Parameters
path:`bytes \| str`	Remote path to fetch from
determine_wants:`DetermineWantsFunc`	Function determine what refs to fetch. Receives dictionary of name->sha, should return list of shas to fetch.
graph_walker:`GraphWalker`	Object with next() and ack().
pack_data:`Callable[[bytes], int]`	Callback called for each bit of data in the pack
progress:`Callable[[bytes], None] \| None`	Callback for progress reports (strings)
depth:`int \| None`	Shallow fetch depth
ref_prefix:`Sequence[bytes] \| None`	List of prefixes of desired references, as a list of bytestrings. Filtering is done by the server if supported, and client side otherwise.
filter_spec:`bytes \| None`	A git-rev-list-style object filter spec, as bytestring. Only used if the server supports the Git protocol-v2 'filter' feature, and ignored otherwise.
protocol_version:`int \| None`	Desired Git protocol version. By default the highest mutually supported protocol version will be used.
shallow_since:`str \| None`	Deepen the history to include commits after this date
shallow_exclude:`list[str] \| None`	Deepen the history to exclude commits reachable from these refs

Returns
`FetchPackResult`	FetchPackResult object

def get_refs(self, path: bytes, protocol_version: int | None = None, ref_prefix: Sequence[bytes] | None = None) -> LsRemoteResult: ¶

overrides dulwich.client.GitClient.get_refs

Retrieve the current refs from a git smart server.

def send_pack(self, path: bytes, update_refs: Callable[[dict[Ref, ObjectID]], dict[Ref, ObjectID]], generate_pack_data: GeneratePackDataFunc, progress: Callable[[bytes], None] | None = None, push_options: Sequence[bytes] | None = None, atomic: bool = False) -> SendPackResult: ¶

overrides dulwich.client.GitClient.send_pack

Upload a pack to a remote repository.

Parameters
path:`bytes`	Repository path (as bytestring)
update_refs:`Callable[[dict[Ref, ObjectID]], dict[Ref, ObjectID]]`	Function to determine changes to remote refs. Receive dict with existing remote refs, returns dict with changed refs (name -> sha, where sha=ZERO_SHA for deletions)
generate_pack_data:`GeneratePackDataFunc`	Function that can return a tuple with number of objects and pack data to upload.
progress:`Callable[[bytes], None] \| None`	Optional callback called with progress updates
push_options:`Sequence[bytes] \| None`	Optional list of push options to send to the server
atomic:`bool`	If True, request atomic push (all refs update or none do)

Returns
`SendPackResult`	SendPackResult

Raises
`SendPackError`	if server rejects the pack data
`GitProtocolError`	if atomic push is requested but server doesn't support it

DEFAULT_ENCODING: str = ¶

Undocumented

Value

'utf-8'

protocol_version = ¶

overrides dulwich.client.GitClient.protocol_version

overridden in dulwich.client.TCPGitClient

Undocumented

def _connect(self, cmd: bytes, path: str | bytes, protocol_version: int | None = None) -> tuple[Protocol, Callable[[], bool], IO[bytes] | None]: ¶

overridden in dulwich.client.SSHGitClient, dulwich.client.SubprocessGitClient, dulwich.client.TCPGitClient

Create a connection to the server.

This method is abstract - concrete implementations should implement their own variant which connects to the server and returns an initialized Protocol object with the service ready for use and a can_read function which may be used to see if reads would block.

Parameters
cmd:`bytes`	The git service name to which we should connect.
path:`str \| bytes`	The path we should pass to the service. (as bytestirng)
protocol_version:`int \| None`	Desired Git protocol version. By default the highest mutually supported protocol version will be used.

Returns
`tuple[Protocol, Callable[[], bool], IO[bytes] \| None]`	Undocumented

_remote_path_encoding = ¶

Undocumented

_report_status_parser = ¶

overrides dulwich.client.GitClient._report_status_parser

Undocumented