# Diff

A diff shows the changes between trees, an index or the working dir.

Repository.diff(a: None | ~_pygit2.Blob | str | bytes | ~_pygit2.Commit | ~_pygit2.Oid | ~_pygit2.Reference = None, b: None | ~_pygit2.Blob | str | bytes | ~_pygit2.Commit | ~_pygit2.Oid | ~_pygit2.Reference = None, cached: bool = False, flags: ~pygit2.enums.DiffOption = <DiffOption.NORMAL: 0>, context_lines: int = 3, interhunk_lines: int = 0) → Diff | Patch

  Show changes between the working tree and the index or a tree, changes between the index and a tree, changes between two trees, or changes between two blobs.

  Keyword arguments:

  a

    None, a str (that refers to an Object, see revparse_single()) or a Reference object. If None, b must be None, too. In this case the working directory is compared with the index. Otherwise the referred object is compared to ‘b’.

  b

    None, a str (that refers to an Object, see revparse_single()) or a Reference object. If None, the working directory is compared to ‘a’. (except ‘cached’ is True, in which case the index is compared to ‘a’). Otherwise the referred object is compared to ‘a’

  cached

    If ‘b’ is None, by default the working directory is compared to ‘a’. If ‘cached’ is set to True, the index/staging area is used for comparing.

  flag

    A combination of enums.DiffOption constants.

  context_lines

    The number of unchanged lines that define the boundary of a hunk (and to display before and after)

  interhunk_lines

    The maximum number of unchanged lines between hunk boundaries before the hunks will be merged into a one

  Examples:

      # Changes in the working tree not yet staged for the next commit
      >>> diff()

      # Changes between the index and your last commit
      >>> diff(cached=True)

      # Changes in the working tree since your last commit
      >>> diff('HEAD')

      # Changes between commits
      >>> t0 = revparse_single('HEAD')
      >>> t1 = revparse_single('HEAD^')
      >>> diff(t0, t1)
      >>> diff('HEAD', 'HEAD^') # equivalent

  If you want to diff a tree against an empty tree, use the low level API (Tree.diff_to_tree()) directly.

Examples

    # Changes between commits
    >>> t0 = revparse_single('HEAD')
    >>> t1 = revparse_single('HEAD^')
    >>> repo.diff(t0, t1)
    >>> t0.diff(t1)           # equivalent
    >>> repo.diff('HEAD', 'HEAD^') # equivalent

    # Get all patches for a diff
    >>> diff = repo.diff('HEAD^', 'HEAD~3')
    >>> patches = [p for p in diff]

    # Get the stats for a diff
    >>> diff = repo.diff('HEAD^', 'HEAD~3')
    >>> diff.stats

    # Diffing the empty tree
    >>> tree = revparse_single('HEAD').tree
    >>> tree.diff_to_tree()

    # Diff empty tree to a tree
    >>> tree = revparse_single('HEAD').tree
    >>> tree.diff_to_tree(swap=True)

## The Diff type

class pygit2.Diff

  Diff objects.

  __iter__()

    Returns an iterator over the deltas/patches in this diff.

  __len__()

    Returns the number of deltas/patches in this diff.

  deltas

    Iterate over the diff deltas.

  find_similar(flags: enums.DiffFind = enums.DiffFind.FIND_BY_CONFIG, rename_threshold: int = 50, copy_threshold: int = 50, rename_from_rewrite_threshold: int = 50, break_rewrite_threshold: int = 60, rename_limit: int = 1000)

    Transform a diff marking file renames, copies, etc.

    This modifies a diff in place, replacing old entries that look like renames or copies with new entries reflecting those changes. This also will, if requested, break modified files into add/remove pairs if the amount of change is above a threshold.

    flags - Combination of enums.DiffFind.FIND_* and enums.DiffFind.BREAK_* constants.

  merge(diff: Diff)

    Merge one diff into another.

  static parse_diff(git_diff: str | bytes) → Diff

    Parses a git unified diff into a diff object without a repository

  patch

    Patch diff string. Can be None in some cases, such as empty commits.

  patchid

    Corresponding patchid.

  stats

    Accumulate diff statistics for all patches.

## The Patch type

Attributes:

class pygit2.Patch

  Diff patch object.

  static create_from()

    Create a patch from blobs, buffers, or a blob and a buffer

  data

    The raw bytes of the patch’s contents.

  delta

    Get the delta associated with a patch.

  hunks
  line_stats

    Get line counts of each type in a patch (context, additions, deletions).

  text

    Patch diff string. Can be None in some cases, such as empty commits. Note that this decodes the content to Unicode assuming UTF-8 encoding. For non-UTF-8 content that can lead be a lossy, non-reversible process. To access the raw, un-decoded patch, use patch.data.

## The DiffDelta type

class pygit2.DiffDelta

  DiffDelta object.

  flags

    A combination of enums.DiffFlag constants.

  is_binary

    True if binary data, False if text, None if not (yet) known.

  new_file

    “to” side of the diff.

  nfiles

    Number of files in the delta.

  old_file

    “from” side of the diff.

  similarity

    For renamed and copied.

  status

    An enums.DeltaStatus constant.

  status_char() → str

    Return the single character abbreviation for a delta status code.

## The DiffFile type

class pygit2.DiffFile

  DiffFile object.

  flags

    A combination of enums.DiffFlag constants.

  static from_c(object, /)

    Method exposed for _checkout_notify_cb to hook into

  id

    Oid of the item.

  mode

    Mode of the entry (an enums.FileMode constant).

  path

    Path to the entry.

  raw_path

    Path to the entry (bytes).

  size

    Size of the entry.

## The DiffHunk type

class pygit2.DiffHunk

  DiffHunk object.

  header

    Header.

  lines

    Lines.

  new_lines

    New lines.

  new_start

    New start.

  old_lines

    Old lines.

  old_start

    Old start.

## The DiffStats type

class pygit2.DiffStats

  DiffStats object.

  deletions

    Total number of deletions

  files_changed

    Total number of files changed

  format(format: enums.DiffStatsFormat, width: int) → str

    Format the stats as a string.

    Returns: str.

    Parameters:

    format

      The format to use. A combination of DiffStatsFormat constants.

    width

      The width of the output. The output will be scaled to fit.

  insertions

    Total number of insertions

## The DiffLine type

class pygit2.DiffLine

  DiffLine object.

  content

    Content of the diff line

  content_offset

    Offset in the original file to the content

  new_lineno

    Line number in new file or -1 for deleted line

  num_lines

    Number of newline characters in content

  old_lineno

    Line number in old file or -1 for added line

  origin

    Type of the diff line

  raw_content

    Content of the diff line (byte string)