dffs 0.0.5__py3-none-any.whl

dffs/__init__.py

@@ -0,0 +1 @@
+from .utils import join_pipelines, get_git_root, get_dir_path

dffs/cli.py

@@ -0,0 +1,9 @@
+from os import environ as env
+
+from click import option, argument
+
+shell_exec_opt = option('-s', '--shell-executable', help=f'Shell to use for executing commands; defaults to $SHELL')
+no_shell_opt = option('-S', '--no-shell', is_flag=True, help="Don't pass `shell=True` to Python `subprocess`es")
+verbose_opt = option('-v', '--verbose', is_flag=True, help="Log intermediate commands to stderr")
+exec_cmd_opt = option('-x', '--exec-cmd', 'exec_cmds', multiple=True, help='Command(s) to execute before invoking `comm`; alternate syntax to passing commands as positional arguments')
+args = argument('args', metavar='[exec_cmd...] <path1> <path2>', nargs=-1)

dffs/comm_x/__init__.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+from click import option, command
+from utz import process
+
+from dffs.cli import args, shell_exec_opt, no_shell_opt, verbose_opt, exec_cmd_opt
+from dffs.utils import join_pipelines
+
+
+@command('comm-x', short_help='comm two files after running them through a pipeline of other commands', no_args_is_help=True)
+@option('-1', '--exclude-1', is_flag=True, help='Exclude lines only found in the first pipeline')
+@option('-2', '--exclude-2', is_flag=True, help='Exclude lines only found in the second pipeline')
+@option('-3', '--exclude-3', is_flag=True, help='Exclude lines found in both pipelines')
+@option('-i', '--case-insensitive', is_flag=True, help='Case insensitive comparison')
+@shell_exec_opt
+@no_shell_opt
+@verbose_opt
+@exec_cmd_opt
+@args
+def main(
+    exclude_1: bool,
+    exclude_2: bool,
+    exclude_3: bool,
+    case_insensitive: bool,
+    shell_executable: str | None,
+    no_shell: bool,
+    verbose: bool,
+    exec_cmds: Tuple[str, ...],
+    args: Tuple[str, ...],
+):
+    """Select or reject lines common to two input streams, after running each through a pipeline of other commands."""
+    if len(args) < 2:
+        raise ValueError('Must provide at least two files to comm')
+
+    *cmds, path1, path2 = args
+    cmds = list(exec_cmds) + cmds
+    if cmds:
+        first, *rest = cmds
+        join_pipelines(
+            base_cmd=[
+                'comm',
+                *(['-1'] if exclude_1 else []),
+                *(['-2'] if exclude_2 else []),
+                *(['-3'] if exclude_3 else []),
+                *(['-i'] if case_insensitive else []),
+            ],
+            cmds1=[ f'{first} {path1}', *rest ],
+            cmds2=[ f'{first} {path2}', *rest ],
+            verbose=verbose,
+            shell=not no_shell,
+            executable=shell_executable,
+        )
+    else:
+        process.run(['comm', path1, path2])

dffs/diff_x/__init__.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import subprocess
+from typing import Tuple
+
+from click import option, command
+
+from dffs.cli import args, shell_exec_opt, no_shell_opt, verbose_opt, exec_cmd_opt
+from dffs.utils import join_pipelines
+
+color_opt = option('-c', '--color', is_flag=True, help='Colorize the output')
+unified_opt = option('-U', '--unified', type=int, help='Number of lines of context to show (passes through to `diff`)')
+ignore_whitespace_opt = option('-w', '--ignore-whitespace', is_flag=True, help="Ignore whitespace differences (pass `-w` to `diff`)")
+
+
+@command('diff-x', short_help='Diff two files after running them through a pipeline of other commands', no_args_is_help=True)
+@color_opt
+@shell_exec_opt
+@no_shell_opt
+@unified_opt
+@verbose_opt
+@ignore_whitespace_opt
+@exec_cmd_opt
+@args
+def main(
+    color: bool,
+    shell_executable: str | None,
+    no_shell: bool,
+    unified: int | None,
+    verbose: bool,
+    ignore_whitespace: bool,
+    exec_cmds: Tuple[str, ...],
+    args: Tuple[str, ...],
+):
+    """Diff two files after running them through a pipeline of other commands."""
+    if len(args) < 2:
+        raise ValueError('Must provide at least two files to diff')
+
+    *cmds, path1, path2 = args
+    cmds = list(exec_cmds) + cmds
+    diff_args = [
+        *(['-w'] if ignore_whitespace else []),
+        *(['-U', str(unified)] if unified is not None else []),
+        *(['--color=always'] if color else []),
+    ]
+    if cmds:
+        first, *rest = cmds
+        join_pipelines(
+            base_cmd=['diff', *diff_args],
+            cmds1=[ f'{first} {path1}', *rest ],
+            cmds2=[ f'{first} {path2}', *rest ],
+            verbose=verbose,
+            shell=not no_shell,
+            executable=shell_executable,
+        )
+    else:
+        subprocess.run(['diff', *diff_args, path1, path2])

dffs/git_diff_x/__init__.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import shlex
+from typing import Tuple
+
+from click import option, argument, command
+from utz import process, err
+
+from dffs.cli import shell_exec_opt, no_shell_opt, verbose_opt, exec_cmd_opt
+from dffs.diff_x import color_opt, unified_opt, ignore_whitespace_opt
+from dffs.utils import join_pipelines
+
+
+@command('git-diff-x', short_help='Diff a Git-tracked file at two commits (or one commit vs. current worktree), optionally passing both through another command first')
+@color_opt
+@option('-r', '--refspec', help='<commit 1>..<commit 2> (compare two commits) or <commit> (compare <commit> to the worktree)')
+@option('-R', '--ref', help="Diff a specific commit; alias for `-r <ref>^..<ref>`")
+@shell_exec_opt
+@no_shell_opt
+@unified_opt
+@verbose_opt
+@ignore_whitespace_opt
+@exec_cmd_opt
+@argument('args', metavar='[exec_cmd...] [<path> | - [paths...]]', nargs=-1)
+def main(
+    color: bool,
+    refspec: str | None,
+    ref: str | None,
+    shell_executable: str | None,
+    no_shell: bool,
+    unified: int | None,
+    verbose: bool,
+    ignore_whitespace: bool,
+    exec_cmds: Tuple[str, ...],
+    args: Tuple[str, ...],
+):
+    """Diff files at two commits, or one commit and the current worktree, after applying an optional command pipeline.
+
+    Examples:
+
+    # Compare the number of lines (`wc -l`) in file `foo` at the previous vs. current commit (`-r HEAD^..HEAD`):
+
+    git diff-x -r HEAD^..HEAD wc -l foo
+
+    # Colorized (`-c`) diff of `md5sum`s of `foo`, at HEAD (last committed value) vs. the current worktree content:
+
+    git diff-x -c md5sum foo
+
+    # Use `-` to separate pipeline commands from paths (when more than one path is to be diffed), e.g. this compares
+    the largest 10 numbers in `file{1,2}` (HEAD vs. worktree):
+
+    git diff-x 'sort -rn' head - file1 file2
+    """
+    if '-' in args:
+        idx = args.index('-')
+        cmd_args = args[:idx]
+        paths = args[idx+1:]
+    else:
+        *cmd_args, path = args
+        paths = [path]
+
+    cmds = list(exec_cmds) + list(cmd_args)
+    shell = not no_shell
+    git_relpath_prefix = process.line('git', 'rev-parse', '--show-prefix', log=False)
+
+    if refspec and ref:
+        raise ValueError("Specify -r/--refspec xor -R/--ref")
+    if ref:
+        refspec = f'{ref}^..{ref}'
+    elif not refspec:
+        refspec = 'HEAD'
+
+    pcs = refspec.split('..', 1)
+    if len(pcs) == 1:
+        ref1 = pcs[0]
+        ref2 = None
+    elif len(pcs) == 2:
+        ref1, ref2 = pcs
+    else:
+        raise ValueError(f"Invalid refspec: {refspec}")
+
+    diff_args = [
+        *(['-w'] if ignore_whitespace else []),
+        *(['-U', str(unified)] if unified is not None else []),
+        *(['--color=always'] if color else []),
+    ]
+    for path in paths:
+        if len(paths) > 1:
+            err(path)
+        if cmds:
+            cmds1 = [ f'git show {ref1}:{git_relpath_prefix}{path}', *cmds ]
+            if ref2:
+                cmds2 = [ f'git show {ref2}:{git_relpath_prefix}{path}', *cmds ]
+            else:
+                cmd, *sub_cmds = cmds
+                cmds2 = [ f'{cmd} {path}', *sub_cmds ]
+            if not shell:
+                cmds1 = [ shlex.split(c) for c in cmds1 ]
+                cmds2 = [ shlex.split(c) for c in cmds2 ]
+
+            join_pipelines(
+                base_cmd=['diff', *diff_args],
+                cmds1=cmds1,
+                cmds2=cmds2,
+                verbose=verbose,
+                shell=not no_shell,
+                executable=shell_executable,
+            )
+        else:
+            process.run(['git', 'diff', *diff_args, refspec, '--', path])

dffs/utils.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from functools import cache
+from os import environ as env, getcwd
+from os.path import relpath
+from subprocess import Popen
+
+from utz import err, named_pipes, pipeline, process
+
+
+@cache
+def get_git_root() -> str:
+    return process.line('git', 'rev-parse', '--show-toplevel', log=False)
+
+
+@cache
+def get_dir_path() -> str:
+    return relpath(getcwd(), get_git_root())
+
+
+def join_pipelines(
+    base_cmd: list[str],
+    cmds1: list[str],
+    cmds2: list[str],
+    verbose: bool = False,
+    executable: str | None = None,
+    **kwargs,
+):
+    """Run two sequences of piped commands, pass their outputs as inputs to a ``base_cmd``.
+
+    Args:
+        base_cmd: Top=level command that takes two positional args (named pipes with the outputs
+            of the ``cmds1`` and ``cmds2`` pipelines).
+        cmds1: First sequence of commands to pipe together
+        cmds2: Second sequence of commands to pipe together
+        verbose: Whether to print commands being executed
+        executable: Shell to use for executing commands; defaults to $SHELL
+        **kwargs: Additional arguments passed to subprocess.Popen
+
+    Each command sequence will be piped together before being compared.
+    For example, if cmds1 = ['cat foo.txt', 'sort'], the function will
+    execute 'cat foo.txt | sort' before comparing with cmds2's output.
+
+    Adapted from https://stackoverflow.com/a/28840955"""
+    if executable is None:
+        executable = env.get('SHELL')
+
+    with named_pipes(n=2) as pipes:
+        (pipe1, pipe2) = pipes
+        join_cmd = [
+            *base_cmd,
+            pipe1,
+            pipe2,
+        ]
+        proc = Popen(join_cmd)
+        processes = [proc]
+
+        for pipe, cmds in ((pipe1, cmds1), (pipe2, cmds2)):
+            if verbose:
+                err(f"Running pipeline: {' | '.join(cmds)}")
+
+            processes += pipeline(
+                cmds,
+                pipe,
+                wait=False,
+                executable=executable,
+                **kwargs,
+            )
+
+        for p in processes:
+            p.wait()
+
+

dffs-0.0.5.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Runs as Coded
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dffs-0.0.5.dist-info/METADATA

@@ -0,0 +1,280 @@
+Metadata-Version: 2.1
+Name: dffs
+Version: 0.0.5
+Summary: Pipe and diff files: execute shell pipelines against multiple inputs, diff/compare/join results.
+Home-page: https://github.com/runsascoded/dffs
+Author: Ryan Williams
+Author-email: ryan@runsascoded.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click
+Requires-Dist: utz>=0.13.0
+
+# dffs
+Pipe and diff files: execute shell pipelines against multiple inputs, diff/compare/join results.
+
+[![dffs on PyPI](https://img.shields.io/pypi/v/dffs?label=dffs)][PyPI]
+<!-- toc -->
+- [Install](#install)
+- [CLIs](#CLIs)
+    - [`diff-x`](#diff-x)
+        - [Usage](#diff-x-usage)
+        - [Examples](#diff-x-examples)
+    - [`comm-x`](#comm-x)
+        - [Usage](#comm-x-usage)
+        - [Examples](#comm-x-examples)
+    - [`git-diff-x`](#git-diff-x)
+        - [Usage](#git-diff-x-usage)
+        - [Examples](#git-diff-x-examples)
+<!-- /toc -->
+
+## Install <a id="install"></a>
+
+```bash
+pip install dffs
+```
+
+## CLIs <a id="CLIs"></a>
+
+### `diff-x` <a id="diff-x"></a>
+
+#### Usage <a id="diff-x-usage"></a>
+<!-- `bmdf diff-x` -->
+```bash
+diff-x
+# Usage: diff-x [OPTIONS] [exec_cmd...] <path1> <path2>
+#
+#   Diff two files after running them through a pipeline of other commands.
+#
+# Options:
+#   -c, --color                  Colorize the output
+#   -s, --shell-executable TEXT  Shell to use for executing commands; defaults
+#                                to $SHELL
+#   -S, --no-shell               Don't pass `shell=True` to Python
+#                                `subprocess`es
+#   -U, --unified INTEGER        Number of lines of context to show (passes
+#                                through to `diff`)
+#   -v, --verbose                Log intermediate commands to stderr
+#   -w, --ignore-whitespace      Ignore whitespace differences (pass `-w` to
+#                                `diff`)
+#   -x, --exec-cmd TEXT          Command(s) to execute before invoking `comm`;
+#                                alternate syntax to passing commands as
+#                                positional arguments
+#   --help                       Show this message and exit.
+```
+
+#### Examples <a id="diff-x-examples"></a>
+
+Given two similar JSON objects, where one is compact and the other is pretty-printed:
+```bash
+echo '{"a":1,"b":2}' > 1.json
+echo '{"a":1,"b":3}' | jq > 2.json 
+```
+
+`diff {1,2}.json` outputs the entirety of both objects:
+```diff
+1c1,4
+< {"a":1,"b":2}
+---
+> {
+>   "a": 1,
+>   "b": 3
+> }
+```
+
+`diff-x 'jq .' {1,2}.json` pretty-prints each side before `diff`ing:
+```diff
+3c3
+<   "b": 2
+---
+>   "b": 3
+```
+
+### `comm-x` <a id="comm-x"></a>
+`comm` essentially performs set intersection/difference; `comm-x` allows you to run a pipeline of commands on each input, before comparing them.
+
+#### Usage <a id="comm-x-usage"></a>
+<!-- `bmdf comm-x` -->
+```bash
+comm-x
+# Usage: comm-x [OPTIONS] [exec_cmd...] <path1> <path2>
+#
+#   Select or reject lines common to two input streams, after running each
+#   through a pipeline of other commands.
+#
+# Options:
+#   -1, --exclude-1              Exclude lines only found in the first pipeline
+#   -2, --exclude-2              Exclude lines only found in the second pipeline
+#   -3, --exclude-3              Exclude lines found in both pipelines
+#   -i, --case-insensitive       Case insensitive comparison
+#   -s, --shell-executable TEXT  Shell to use for executing commands; defaults
+#                                to $SHELL
+#   -S, --no-shell               Don't pass `shell=True` to Python
+#                                `subprocess`es
+#   -v, --verbose                Log intermediate commands to stderr
+#   -x, --exec-cmd TEXT          Command(s) to execute before invoking `comm`;
+#                                alternate syntax to passing commands as
+#                                positional arguments
+#   --help                       Show this message and exit.
+```
+
+#### Examples <a id="comm-x-examples"></a>
+Given two similar lists of numbers, but in different orders:
+```bash
+seq 10 > 1.txt
+seq 10 -2 0 > 2.txt
+```
+
+`comm` outputs gibberish, because the files aren't in sorted order:
+<!-- `bmdf comm 1.txt 2.txt` -->
+```bash
+comm 1.txt 2.txt
+# 1
+# 	10
+# 2
+# 3
+# 4
+# 5
+# 6
+# 7
+# 		8
+# comm: file 2 is not in sorted order
+# 	6
+# 	4
+# 	2
+# 	0
+# 9
+# comm: file 1 is not in sorted order
+# 10
+# comm: input is not in sorted order
+```
+
+`comm-x sort` sorts each file first:
+<!-- `bmdf comm-x sort 1.txt 2.txt` -->
+```bash
+comm-x sort 1.txt 2.txt
+# 	0
+# 1
+# 		10
+# 		2
+# 3
+# 		4
+# 5
+# 		6
+# 7
+# 		8
+# 9
+```
+
+### `git-diff-x` <a id="git-diff-x"></a>
+
+#### Usage <a id="git-diff-x-usage"></a>
+<!-- `bmdf -- git-diff-x --help` -->
+```bash
+git-diff-x --help
+# Usage: git-diff-x [OPTIONS] [exec_cmd...] [<path> | - [paths...]]
+#
+#   Diff files at two commits, or one commit and the current worktree, after
+#   applying an optional command pipeline.
+#
+#   Examples:
+#
+#   # Compare the number of lines (`wc -l`) in file `foo` at the previous vs.
+#   current commit (`-r HEAD^..HEAD`):
+#
+#   git diff-x -r HEAD^..HEAD wc -l foo
+#
+#   # Colorized (`-c`) diff of `md5sum`s of `foo`, at HEAD (last committed
+#   value) vs. the current worktree content:
+#
+#   git diff-x -c md5sum foo
+#
+#   # Use `-` to separate pipeline commands from paths (when more than one path
+#   is to be diffed), e.g. this compares the largest 10 numbers in `file{1,2}`
+#   (HEAD vs. worktree):
+#
+#   git diff-x 'sort -rn' head - file1 file2
+#
+# Options:
+#   -c, --color                  Colorize the output
+#   -r, --refspec TEXT           <commit 1>..<commit 2> (compare two commits) or
+#                                <commit> (compare <commit> to the worktree)
+#   -R, --ref TEXT               Diff a specific commit; alias for `-r
+#                                <ref>^..<ref>`
+#   -s, --shell-executable TEXT  Shell to use for executing commands; defaults
+#                                to $SHELL
+#   -S, --no-shell               Don't pass `shell=True` to Python
+#                                `subprocess`es
+#   -U, --unified INTEGER        Number of lines of context to show (passes
+#                                through to `diff`)
+#   -v, --verbose                Log intermediate commands to stderr
+#   -w, --ignore-whitespace      Ignore whitespace differences (pass `-w` to
+#                                `diff`)
+#   -x, --exec-cmd TEXT          Command(s) to execute before invoking `comm`;
+#                                alternate syntax to passing commands as
+#                                positional arguments
+#   --help                       Show this message and exit.
+```
+
+#### Examples <a id="git-diff-x-examples"></a>
+Compare line-count (`wc -l`) of this README, before and after commit `8b7a761`:
+<!-- `bmdf -- git-diff-x -R 8b7a761 'wc -l' README.md` -->
+```bash
+git-diff-x -R 8b7a761 'wc -l' README.md
+# 1c1
+# < 16
+# ---
+# > 206
+```
+
+Examples from `--help` above:
+```bash
+# Compare the number of lines (`wc -l`) in file `foo` at the previous vs. current commit
+# (`-R HEAD` is equivalent to `-r HEAD^..HEAD`).
+git diff-x -R HEAD wc -l foo
+
+# Colorized (`-c`) diff of `md5sum`s of `foo`, at HEAD (last committed value) vs. the current
+# worktree content.
+git diff-x -c md5sum foo
+
+# Use `-` to separate pipeline commands from paths (when more than one path is to be diffed),
+# e.g. this compares the largest 10 numbers in `file{1,2}` (HEAD vs. worktree):
+git diff-x 'sort -rn' head - file1 file2
+```
+
+I use `git-diff-x` via several Git and Bash aliases:
+
+[`.gitconfig`][diff-x git configs]:
+```.gitconfig
+[alias]
+  ; pip install dffs
+  dx = diff-x
+  dxc = diff-x -c
+  dxcr = diff-x -cR
+  dxcrr = diff-x -cr
+  dxr = diff-x -R
+  dxrr = diff-x -r
+  dxw = diff-x -w
+  dxwr = diff-x -wR
+  dxwrr = diff-x -wr
+```
+
+[`.git-rc`][diff-x aliases]:
+```bash
+alias gdx="g dx"
+alias gdxc="g dxc"
+alias gdxcr="g dxcr"
+alias gdxcrr="g dxcrr"
+alias gdxr="g dxr"
+alias gdxrr="g dxrr"
+alias gdxw="g dxw"
+alias gdxwr="g dxwr"
+alias gdxwrr="g dxwrr"
+```
+
+[`jq`]: https://stedolan.github.io/jq/
+[PyPI]: https://pypi.org/project/dffs/
+
+[diff-x git configs]: https://github.com/ryan-williams/git-helpers/blob/5f27c2e4e88e3e14ede21483c998bdbe2cfccc6f/diff/.gitconfig#L64-L73
+[diff-x aliases]: https://github.com/ryan-williams/git-helpers/blob/5f27c2e4e88e3e14ede21483c998bdbe2cfccc6f/diff/.git-rc#L59-L67

dffs-0.0.5.dist-info/RECORD

@@ -0,0 +1,12 @@
+dffs/__init__.py,sha256=89i9IY6_uQ0Wj_OmzChDfzN3uGlobCFckMejrIs1cnY,62
+dffs/cli.py,sha256=SRkeSyWuXLe05orCrK_X8gg6F2eDT4T84OB30OQrPGE,655
+dffs/utils.py,sha256=g35SCST65ft_5_2zXKwPvbQdlEIXSu13l0Ita_T_Ae4,2088
+dffs/comm_x/__init__.py,sha256=tUFC21cmBkmUr0nOn6nlghFtGzIsDeXDJkNpEDGeZTY,1906
+dffs/diff_x/__init__.py,sha256=lxecRKUakou3Sg8nZFTLTgISPIZuEKnJ1v9_2htdI4A,1832
+dffs/git_diff_x/__init__.py,sha256=aOAQwa2DdrTlJrxF8mIP8pWqEFc8yAZaaag9DcUomZ4,3608
+dffs-0.0.5.dist-info/LICENSE,sha256=tNEc4t-f14dXtZppT5u1eRdYgvwLcFY-ZCn_TmhhXQ4,1070
+dffs-0.0.5.dist-info/METADATA,sha256=XvFp3Co0GqR5vs4bnkAsNN-LtFsxLdPajiBEgqdqSRc,8328
+dffs-0.0.5.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+dffs-0.0.5.dist-info/entry_points.txt,sha256=8NiFTRDOkvSNaNCHGupz2OkfBZqPKOj-GpisKJufR3I,104
+dffs-0.0.5.dist-info/top_level.txt,sha256=FkFAcPfGiM1znGhny7sQpbccZHGD3lAxD5hyhtlONU4,5
+dffs-0.0.5.dist-info/RECORD,,

dffs-0.0.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dffs-0.0.5.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+comm-x = dffs.comm_x:main
+diff-x = dffs.diff_x:main
+git-diff-x = dffs.git_diff_x:main

dffs-0.0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+dffs