# Diff

Contents

- Diff
  - The Diff type
  - The Patch type
  - The DiffDelta type
  - The DiffFile type
  - The DiffHunk type
  - The DiffStats type
  - The DiffLine type

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

`Repository.``diff`(a=None, b=None, cached=False, flags=0, context_lines=3, interhunk_lines=0)

  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 GIT_DIFF_* constant
  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

`Diff.``patch`

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

`Diff.``__iter__`()

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

`Diff.``__len__`()

  Returns the number of deltas/patches in this diff.

`Diff.``merge`(diff)

  Merge one diff into another.

`Diff.``find_similar`([flags, rename_threshold, copy_threshold, rename_from_rewrite_threshold, break_rewrite_threshold, rename_limit])

  Find renamed files in diff and updates them in-place in the diff itself.

## 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

  `delta`

    Get the delta associated with a patch.

  `hunks`
  `line_stats`

    Get line counts of each type in a patch.

  `patch`

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

## The DiffDelta type

class `pygit2.``DiffDelta`

  DiffDelta object.

  `flags`

    Combination of GIT_DIFF_FLAG_* flags.

  `is_binary`

    True if binary data, False if not.

  `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`

    A GIT_DELTA_* constant.

  `status_char`()

    Return the single character abbreviation for a delta status code.

## The DiffFile type

class `pygit2.``DiffFile`

  DiffFile object.

  `flags`

    Combination of GIT_DIFF_FLAG_* flags.

  `id`

    Oid of the item.

  `mode`

    Mode of the entry.

  `path`

    Path to the entry.

  `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, width)

    Format the stats as a string.

    Returns: str.

    Parameters:

    format
      The format to use. A pygit2.GIT_DIFF_STATS_* constant.
    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