bsdiff4 1.3.0__cp312-cp312-win_arm64.whl

bsdiff4/__init__.py

@@ -0,0 +1,9 @@
+from bsdiff4.format import (diff, patch, file_diff, file_patch,
+                            file_patch_inplace)
+
+__version__ = "1.3.0"
+
+
+def test(verbosity=1):
+    from .test_all import run
+    return run(verbosity=verbosity)

bsdiff4/cli.py

@@ -0,0 +1,94 @@
+from __future__ import absolute_import
+
+from os.path import getsize
+from optparse import OptionParser
+
+from bsdiff4.format import file_diff, file_patch, read_patch
+
+
+def display_version():
+    from bsdiff4 import __version__
+    print("bsdiff4 %s" % __version__)
+
+
+def human_bytes(n):
+    """
+    return the number of bytes 'n' in more human readable form
+    """
+    if n < 1024:
+        return '%i B' % n
+    k = (n - 1) / 1024 + 1
+    if k < 1024:
+        return '%i KB' % k
+    return '%.2f MB' % (float(n) / (2 ** 20))
+
+
+def main_bsdiff4():
+    p = OptionParser(
+        usage="usage: %prog [options] SRC DST PATCH",
+        description=("generate a BSDIFF4-format PATCH from SRC to DST "
+                     "and write it to PATCH"))
+
+    p.add_option('-v', "--verbose",
+                 action="store_true")
+
+    p.add_option("--version",
+                 action="store_true")
+
+    opts, args = p.parse_args()
+
+    if opts.version:
+        display_version()
+        return
+
+    if len(args) != 3:
+        p.error('requies 3 arguments, try -h')
+
+    file_diff(*args)
+    if opts.verbose:
+        size = [getsize(args[i]) for i in range(3)]
+        print('src: %s' % human_bytes(size[0]))
+        print('dst: %s' % human_bytes(size[1]))
+        print('patch: %s (%.2f%% of dst)' % (human_bytes(size[2]),
+                                             100.0 * size[2] / size[1]))
+
+
+def show_patch(patch_path):
+    s_total = getsize(patch_path)
+    fi = open(patch_path, 'rb')
+    s_control, s_diff, s_dst, tcontrol = read_patch(fi, header_only=True)
+    fi.close()
+    s_extra = s_total - 32 - s_control - s_diff
+
+    for var_name in 'total', 'control', 'diff', 'extra', 'dst':
+        size = eval('s_' + var_name)
+        print('%s size: %d (%s)' % (var_name, size, human_bytes(size)))
+    print('total / dst = %.2f%%' % (100.0 * s_total / s_dst))
+    print('number of control tuples: %d' % len(tcontrol))
+    #for t in tcontrol:
+    #    print('%20d %10d %10d' % t)
+
+
+def main_bspatch4():
+    p = OptionParser(
+        usage="usage: %prog [options] SRC DST PATCH",
+        description=("genertaes DST, by applying the BSDIFF4-format PATCH "
+                     "file to SRC"))
+
+    p.add_option("--version",
+                 action="store_true")
+
+    opts, args = p.parse_args()
+
+    if opts.version:
+        display_version()
+        return
+
+    if len(args) == 1:
+        show_patch(args[0])
+        return
+
+    if len(args) != 3:
+        p.error('requies 3 arguments, try -h')
+
+    file_patch(*args)

bsdiff4/format.py

@@ -0,0 +1,119 @@
+import bz2
+import sys
+from io import BytesIO
+
+
+MAGIC = b'BSDIFF40'
+
+
+import bsdiff4.core as core
+
+
+def write_patch(fo, len_dst, tcontrol, bdiff, bextra):
+    """write a BSDIFF4-format patch to stream 'fo'
+    """
+    fo.write(MAGIC)
+    faux = BytesIO()
+    # write control tuples as series of offts
+    for c in tcontrol:
+        for x in c:
+            faux.write(core.encode_int64(x))
+    # compress each block
+    bcontrol = bz2.compress(faux.getvalue())
+    bdiff = bz2.compress(bdiff)
+    bextra = bz2.compress(bextra)
+    for n in len(bcontrol), len(bdiff), len_dst:
+        fo.write(core.encode_int64(n))
+    fo.write(bcontrol)
+    fo.write(bdiff)
+    fo.write(bextra)
+
+
+def read_patch(fi, header_only=False):
+    """read a BSDIFF4-format patch from stream 'fi'
+    """
+    magic = fi.read(8)
+    if magic[:7] != MAGIC[:7]:
+        raise ValueError("incorrect magic bsdiff4 header")
+    # length headers
+    len_control = core.decode_int64(fi.read(8))
+    len_diff = core.decode_int64(fi.read(8))
+    len_dst = core.decode_int64(fi.read(8))
+    # read the control header
+    bcontrol = bz2.decompress(fi.read(len_control))
+    tcontrol = [(core.decode_int64(bcontrol[i:i + 8]),
+                 core.decode_int64(bcontrol[i + 8:i + 16]),
+                 core.decode_int64(bcontrol[i + 16:i + 24]))
+                for i in range(0, len(bcontrol), 24)]
+    if header_only:
+        return len_control, len_diff, len_dst, tcontrol
+    # read the diff and extra blocks
+    bdiff = bz2.decompress(fi.read(len_diff))
+    bextra = bz2.decompress(fi.read())
+    return len_dst, tcontrol, bdiff, bextra
+
+
+def read_data(path):
+    with open(path, 'rb') as fi:
+        data = fi.read()
+    return data
+
+
+def diff(src_bytes, dst_bytes):
+    """diff(src_bytes, dst_bytes) -> bytes
+
+    Return a BSDIFF4-format patch (from src_bytes to dst_bytes) as bytes.
+    """
+    faux = BytesIO()
+    write_patch(faux, len(dst_bytes), *core.diff(src_bytes, dst_bytes))
+    return faux.getvalue()
+
+
+def file_diff(src_path, dst_path, patch_path):
+    """file_diff(src_path, dst_path, patch_path)
+
+    Write a BSDIFF4-format patch (from the file src_path to the file dst_path)
+    to the file patch_path.
+    """
+    src = read_data(src_path)
+    dst = read_data(dst_path)
+    with open(patch_path, 'wb') as fo:
+        write_patch(fo, len(dst), *core.diff(src, dst))
+
+
+def patch(src_bytes, patch_bytes):
+    """patch(src_bytes, patch_bytes) -> bytes
+
+    Apply the BSDIFF4-format patch_bytes to src_bytes and return the bytes.
+    """
+    return core.patch(src_bytes, *read_patch(BytesIO(patch_bytes)))
+
+
+def file_patch_inplace(path, patch_path):
+    """file_patch_inplace(path, patch_path)
+
+    Apply the BSDIFF4-format file patch_path to the file 'path' in place.
+    """
+    with open(patch_path, 'rb') as fi:
+        with open(path, 'r+b') as fo:
+            data = fo.read()
+            fo.seek(0)
+            fo.write(core.patch(data, *read_patch(fi)))
+            fo.truncate()
+
+
+def file_patch(src_path, dst_path, patch_path):
+    """file_patch(src_path, dst_path, patch_path)
+
+    Apply the BSDIFF4-format file patch_path to the file src_path and
+    write the result to the file dst_path.
+    """
+    from os.path import abspath
+
+    if abspath(dst_path) == abspath(src_path):
+        file_patch_inplace(src_path, patch_path)
+        return
+
+    with open(patch_path, 'rb') as fi:
+        with open(dst_path, 'wb') as fo:
+            fo.write(core.patch(read_data(src_path), *read_patch(fi)))

bsdiff4/test_all.py

@@ -0,0 +1,164 @@
+from __future__ import absolute_import
+
+import os
+import sys
+import random
+import shutil
+import unittest
+import tempfile
+
+import bsdiff4.core as core
+import bsdiff4.format as format
+from bsdiff4 import diff, patch, file_diff, file_patch, file_patch_inplace
+
+
+N = 2 ** 63 - 1
+
+
+class TestEncode(unittest.TestCase):
+
+    def test_special_values(self):
+        for n, b in [
+            (-N, b'\xff\xff\xff\xff\xff\xff\xff\xff'),
+            (-256, b'\x00\x01\x00\x00\x00\x00\x00\x80'),
+            (-128, b'\x80\x00\x00\x00\x00\x00\x00\x80'),
+            (-1, b'\x01\x00\x00\x00\x00\x00\x00\x80'),
+            (0, b'\x00\x00\x00\x00\x00\x00\x00\x00'),
+            (1, b'\x01\x00\x00\x00\x00\x00\x00\x00'),
+            (127, b'\x7f\x00\x00\x00\x00\x00\x00\x00'),
+            (128, b'\x80\x00\x00\x00\x00\x00\x00\x00'),
+            (129, b'\x81\x00\x00\x00\x00\x00\x00\x00'),
+            (255, b'\xff\x00\x00\x00\x00\x00\x00\x00'),
+            (256, b'\x00\x01\x00\x00\x00\x00\x00\x00'),
+            (257, b'\x01\x01\x00\x00\x00\x00\x00\x00'),
+            (N, b'\xff\xff\xff\xff\xff\xff\xff\x7f'),
+            ]:
+            self.assertEqual(core.encode_int64(n), b)
+            self.assertEqual(core.decode_int64(b), n)
+
+    def test_errors(self):
+        self.assertRaises(TypeError, core.encode_int64, 'x')
+        self.assertRaises(TypeError, core.decode_int64, 12345)
+        self.assertRaises(ValueError, core.decode_int64, 7 * b'a')
+        self.assertRaises(ValueError, core.decode_int64, 9 * b'b')
+
+    def test_random(self):
+        for dum in range(1000):
+            n = random.randint(-N, N)
+            b = core.encode_int64(n)
+            self.assertEqual(len(b), 8)
+            self.assertEqual(core.decode_int64(b), n)
+
+
+class TestFormat(unittest.TestCase):
+
+    def round_trip(self, src, dst):
+        p = diff(src, dst)
+        #print(len(src), len(p))
+        dst2 = patch(src, p)
+        self.assertEqual(dst, dst2)
+
+    def test_zero(self):
+        self.round_trip(b'', b'')
+
+    def test_extra(self):
+        src = os.urandom(1000)
+        dst = src + os.urandom(10)
+        self.round_trip(src, dst)
+        self.round_trip(dst, src)
+
+    def test_small(self): # issue #14
+        src = b'123456789 987654321'
+        dst = b'123456789000987654321'
+        self.round_trip(src, dst)
+        self.round_trip(dst, src)
+
+    def test_random(self):
+        for _ in range(100):
+            n1 = random.randint(0, 1000)
+            n2 = random.randint(0, 1000)
+            self.round_trip(os.urandom(n1), os.urandom(n2))
+
+    def test_large(self):
+        a = os.urandom(50000)
+        b = os.urandom(40000)
+        src = a + os.urandom(100) + b
+        dst = a + os.urandom(100) + b
+        self.round_trip(src, dst)
+
+
+class TestFile(unittest.TestCase):
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+
+    def path(self, fn):
+        return os.path.join(self.tmpdir, fn)
+
+    def assert_same_file_content(self, fn1, fn2):
+        data1 = format.read_data(self.path(fn1))
+        data2 = format.read_data(self.path(fn2))
+        self.assertEqual(data1, data2)
+
+    def round_trip(self):
+        # write file 'patch'
+        file_diff(self.path('src'), self.path('dst'), self.path('patch'))
+        # write file 'dst2'
+        file_patch(self.path('src'), self.path('dst2'), self.path('patch'))
+        # compare files 'dst' and 'dst2'
+        self.assert_same_file_content('dst', 'dst2')
+        # patch 'src' in place
+        file_patch(self.path('src'), self.path('src'), self.path('patch'))
+        self.assert_same_file_content('src', 'dst')
+
+    def write_data(self, fn, data):
+        with open(self.path(fn), 'wb') as fo:
+            fo.write(data)
+
+    def test_wrong_header(self):
+        path = self.path('foo')
+        self.write_data(path, b"WRONG_HEADER")
+        with open(path, "rb") as fi:
+            self.assertRaises(ValueError, format.read_patch, fi)
+
+    def test_1(self):
+        a = 1000 * b'ABCDE'
+        b = 1000 * b'XYZ'
+        self.write_data('src', a + os.urandom(100) + b)
+        self.write_data('dst', a + os.urandom(100) + b)
+        self.round_trip()
+
+    def test_2(self):
+        a = 10000 * b'ABCDEFG'
+        self.write_data('src', a)
+        self.write_data('dst', a + b'extra bytes at the end')
+        self.round_trip()
+
+    def test_inplace(self):
+        a = 1000 * b'ABCDE'
+        b = 1000 * b'XYZ'
+        self.write_data('src', a + os.urandom(100) + b)
+        self.write_data('dst', a + os.urandom(100) + b)
+        file_diff(self.path('src'), self.path('dst'), self.path('patch'))
+        file_patch_inplace(self.path('src'), self.path('patch'))
+        self.assert_same_file_content('src', 'dst')
+
+
+def run(verbosity=1):
+    from . import __version__
+    print('Python version: %s' % sys.version)
+    print('bsdiff4 is installed in: %s' % os.path.dirname(__file__))
+    print('bsdiff4 version: %s' % __version__)
+
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+    suite.addTests(loader.loadTestsFromModule(sys.modules[__name__]))
+    runner = unittest.TextTestRunner(verbosity=verbosity)
+    return runner.run(suite)
+
+
+if __name__ == '__main__':
+    unittest.main()

bsdiff4-1.3.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: bsdiff4
+Version: 1.3.0
+Summary: binary diff and patch using the BSDIFF4-format
+Home-page: https://github.com/ilanschnell/bsdiff4
+Author: Ilan Schnell
+Author-email: ilanschnell@gmail.com
+License: BSD
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Utilities
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+=======================================================
+bsdiff4: binary diff and patch using the BSDIFF4-format
+=======================================================
+
+The code is mostly derived from cx_bsdiff (written by Anthony Tuininga,
+http://cx-bsdiff.sourceforge.net/).  The cx_bsdiff code in turn was derived
+from bsdiff, the standalone utility produced for BSD which can be found
+at http://www.daemonology.net/bsdiff.
+In addition to the two functions (diff and patch) cx_bsdiff provides, this
+package includes:
+
+* an interface to the BSDIFF4-format
+* command line interfaces: bsdiff4 and bspatch4
+* tests
+
+
+The bsdiff4 package defines the following high level functions:
+
+``diff(src_bytes, dst_bytes)`` -> bytes
+   Return a BSDIFF4-format patch (from ``src_bytes`` to ``dst_bytes``) as
+   bytes.
+
+``patch(src_bytes, patch_bytes)`` -> bytes
+   Apply the BSDIFF4-format ``patch_bytes`` to ``src_bytes`` and return
+   the bytes.
+
+``file_diff(src_path, dst_path, patch_path)``
+   Write a BSDIFF4-format patch (from the file ``src_path`` to the
+   file ``dst_path``) to the file ``patch_path``.
+
+``file_patch(src_path, dst_path, patch_path)``
+   Apply the BSDIFF4-format file ``patch_path`` to the file ``src_path``
+   and write the result to the file ``dst_path``.
+
+``file_patch_inplace(path, patch_path)``
+   Apply the BSDIFF4-format file ``patch_path`` to the file ``path``
+   in place.
+
+
+Example:
+
+.. code-block:: python
+
+   >>> import bsdiff4
+   >>> a = 100000 * b'a'
+   >>> b = bytearray(a)
+   >>> b[100:106] = b' diff '
+   >>> p = bsdiff4.diff(a, bytes(b))
+   >>> len(p)
+   154
+   >>> bsdiff4.patch(a, p) == b
+   True

bsdiff4-1.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+bsdiff4/__init__.py,sha256=uD-wSA2liY7LD3pcPBJ_MDxlPi0jGsUDLV8NOEG6MmI,235
+bsdiff4/cli.py,sha256=TYDrcsIHtKAnL6nIqpoJJ9iRq40lKs0EnzEBMYaZZWA,2603
+bsdiff4/core.cp312-win_arm64.pyd,sha256=ac8RQiwDxiThTILsxTlyO3UEocDLTXeiq9rS80s772w,17920
+bsdiff4/format.py,sha256=SLRULsyLtCjwTVhTCyOMcPsRXExZsMqay89mIhSJg_w,3604
+bsdiff4/test_all.py,sha256=rClODbNA0YpBZIb94Twgf5VtmruGVCZQtYfHxzgTTpQ,5394
+bsdiff4-1.3.0.dist-info/licenses/LICENSE,sha256=FuNPTpHAVJMAMJvZiD52afLpYqgpNQyqDUxRR2P4PgQ,8486
+bsdiff4-1.3.0.dist-info/METADATA,sha256=4ydDEYd8Td5q0e_YOT4ChKW5cBcQFTEcekKtiH3_cB4,2838
+bsdiff4-1.3.0.dist-info/WHEEL,sha256=tpnnFzlMRXtBlhRYqrPGibHbOlqmThF0q8oKK-muSzM,101
+bsdiff4-1.3.0.dist-info/entry_points.txt,sha256=9-ctLCIhmwihoYlF4S15zv5gksMRd9UqhUqmWmLRaXs,90
+bsdiff4-1.3.0.dist-info/top_level.txt,sha256=1upCuxINieZyLC4s1zsrmG3UqQfCi0vKqeRDmpjCk3E,8
+bsdiff4-1.3.0.dist-info/RECORD,,

bsdiff4-1.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_arm64
+

bsdiff4-1.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bsdiff4 = bsdiff4.cli:main_bsdiff4
+bspatch4 = bsdiff4.cli:main_bspatch4

bsdiff4-1.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,156 @@
+Copyright (c) 2011-2025, Ilan Schnell
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+either expressed or implied, of the (Python) bsdiff4 project.
+
+
+/***************************************************************************
+ *  the module bsdiff4/core.c has been drived from cx_bsdiff written by    *
+ *  Anthony Tuininga, http://cx-bsdiff.sourceforge.net/), which was        *
+ *  released under the BSD Protection License below                        *
+ ***************************************************************************/
+
+
+BSD Protection License
+February 2002
+
+Preamble
+--------
+
+The Berkeley Software Distribution ("BSD") license has proven very effective
+over the years at allowing for a wide spread of work throughout both
+commercial and non-commercial products.  For programmers whose primary
+intention is to improve the general quality of available software, it is
+arguable that there is no better license than the BSD license, as it
+permits improvements to be used wherever they will help, without idealogical
+or metallic constraint.
+
+This is of particular value to those who produce reference implementations
+of proposed standards: The case of TCP/IP clearly illustrates that freely
+and universally available implementations leads the rapid acceptance of
+standards -- often even being used instead of a de jure standard (eg, OSI
+network models).
+
+With the rapid proliferation of software licensed under the GNU General
+Public License, however, the continued success of this role is called into
+question.  Given that the inclusion of a few lines of "GPL-tainted" work
+into a larger body of work will result in restricted distribution -- and
+given that further work will likely build upon the "tainted" portions,
+making them difficult to remove at a future date -- there are inevitable
+circumstances where authors would, in order to protect their goal of
+providing for the widespread usage of their work, wish to guard against
+such "GPL-taint".
+
+In addition, one can imagine that companies which operate by producing and
+selling (possibly closed-source) code would wish to protect themselves
+against the rise of a GPL-licensed competitor.  While under existing
+licenses this would mean not releasing their code under any form of open
+license, if a license existed under which they could incorporate any
+improvements back into their own (commercial) products then they might be
+far more willing to provide for non-closed distribution.
+
+For the above reasons, we put forth this "BSD Protection License": A
+license designed to retain the freedom granted by the BSD license to use
+licensed works in a wide variety of settings, both non-commercial and
+commercial, while protecting the work from having future contributors
+restrict that freedom.
+
+The precise terms and conditions for copying, distribution, and
+modification follow.
+
+BSD PROTECTION LICENSE
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION, AND MODIFICATION
+----------------------------------------------------------------
+
+0. Definitions.
+   a) "Program", below, refers to any program or work distributed under
+      the terms of this license.
+   b) A "work based on the Program", below, refers to either the Program
+      or any derivative work under copyright law.
+   c) "Modification", below, refers to the act of creating derivative works.
+   d) "You", below, refers to each licensee.
+
+1. Scope.
+   This license governs the copying, distribution, and modification of the
+   Program.  Other activities are outside the scope of this license; The
+   act of running the Program is not restricted, and the output from the
+   Program is covered only if its contents constitute a work based on the
+   Program.
+
+2. Verbatim copies.
+   You may copy and distribute verbatim copies of the Program as you
+   receive it, in any medium, provided that you conspicuously and
+   appropriately publish on each copy an appropriate copyright notice; keep
+   intact all the notices that refer to this License and to the absence of
+   any warranty; and give any other recipients of the Program a copy of this
+   License along with the Program.
+
+3. Modification and redistribution under closed license.
+   You may modify your copy or copies of the Program, and distribute
+   the resulting derivative works, provided that you meet the
+   following conditions:
+   a) The copyright notice and disclaimer on the Program must be reproduced
+      and included in the source code, documentation, and/or other materials
+      provided in a manner in which such notices are normally distributed.
+   b) The derivative work must be clearly identified as such, in order that
+      it may not be confused with the original work.
+   c) The license under which the derivative work is distributed must
+      expressly prohibit the distribution of further derivative works.
+
+4. Modification and redistribution under open license.
+   You may modify your copy or copies of the Program, and distribute
+   the resulting derivative works, provided that you meet the
+   following conditions:
+   a) The copyright notice and disclaimer on the Program must be reproduced
+      and included in the source code, documentation, and/or other materials
+      provided in a manner in which such notices are normally distributed.
+   b) You must clearly indicate the nature and date of any changes made
+      to the Program.  The full details need not necessarily be included in
+      the individual modified files, provided that each modified file is
+      clearly marked as such and instructions are included on where the
+      full details of the modifications may be found.
+   c) You must cause any work that you distribute or publish, that in whole
+      or in part contains or is derived from the Program or any part
+      thereof, to be licensed as a whole at no charge to all third
+      parties under the terms of this License.
+
+5. Implied acceptance.
+   You may not copy or distribute the Program or any derivative works except
+   as expressly provided under this license.  Consequently, any such action
+   will be taken as implied acceptance of the terms of this license.
+
+6. NO WARRANTY.
+   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+   THE COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+   REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE FOR ANY DIRECT,
+   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING, BUT
+   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+   TORT, EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGES.

bsdiff4-1.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bsdiff4