pip2pi-dev 0.9.0__py3-none-any.whl

libpip2pi/__init__.py

@@ -0,0 +1 @@
+__version__ = (0, 9, 0)

libpip2pi/commands.py

@@ -0,0 +1,615 @@
+import os
+import re
+import sys
+import shutil
+import atexit
+import tempfile
+import warnings
+import textwrap
+import functools
+from subprocess import check_call
+import glob
+import optparse
+
+try:
+    from html import escape
+except ImportError:
+    from cgi import escape
+
+try:
+    import wheel as _; _
+    has_wheel = True
+except ImportError:
+    has_wheel = False
+
+
+def try_int(x):
+    try:
+        return int(x)
+    except ValueError:
+        return x
+
+pip_download_command = 'download --dest'
+pip_no_binary_command = '--no-binary=:all:'
+
+class PipError(Exception):
+    pass
+
+def warn_wheel():
+    print(
+        "ERROR: .whl packages were downloaded but the wheel package "
+        "is not installed, so they cannot be correctly processed.\n"
+        "Install it with:\n"
+        "    pip install wheel"
+    )
+    try:
+        import setuptools
+        setuptools_version = setuptools.__version__
+    except ImportError:
+        setuptools_version = ''
+    if setuptools_version < '1.0.0':
+        print(
+            "WARNING: your setuptools package is out of date. This "
+            "could lead to bad things.\n"
+            "You should likely update it:\n"
+            "    pip install -U setuptools"
+        )
+
+def dedent(text):
+    return textwrap.dedent(text.lstrip("\n")).rstrip()
+
+def maintain_cwd(f):
+    @functools.wraps(f)
+    def maintain_cwd_helper(*args, **kwargs):
+        orig_dir = os.getcwd()
+        try:
+            return f(*args, **kwargs)
+        finally:
+            os.chdir(orig_dir)
+    return maintain_cwd_helper
+
+class InvalidFilePackageName(ValueError):
+    def __init__(self, file, basedir=None):
+        msg = "unexpected file name: %r " %(file, )
+        msg += "(not in 'pkg-name-version.xxx' format"
+        if basedir:
+            msg += "; found in directory: %r" %(basedir)
+        msg += ")"
+        super(InvalidFilePackageName, self).__init__(msg)
+
+
+def safe_name(name):
+    """Convert an arbitrary string to a standard distribution name
+
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    Copied from pkg_resources.
+    """
+    return re.sub('[^A-Za-z0-9.]+', '-', name)
+
+# Copied from pkg_resources.
+EGG_NAME = re.compile(
+    r"""
+    (?P<name>[^-]+) (
+        -(?P<ver>[^-]+) (
+            -py(?P<pyver>[^-]+) (
+                -(?P<plat>.+)
+            )?
+        )?
+    )?
+    """,
+    re.VERBOSE | re.IGNORECASE,
+).match
+
+
+def egg_project_name(filename):
+    project_name, version, py_version, platform = [None] * 4
+    basename, ext = os.path.splitext(filename)
+    match = EGG_NAME(basename)
+    if match:
+        project_name = match.group("name")
+    return safe_name(project_name or 'Unknown')
+
+
+def file_to_package(file, basedir=None):
+    """ Returns the package name for a given file, or raises an
+        ``InvalidFilePackageName`` exception if the file name is
+        not valid::
+
+        >>> file_to_package("foo-1.2.3_rc1.tar.gz")
+        ('foo', '1.2.3-rc1.tar.gz')
+        >>> file_to_package("foo-bar-1.2.tgz")
+        ('foo-bar', '1.2.tgz')
+        >>> file_to_package("kafka-quixey-0.8.1-1.tar.gz")
+        ('kafka-quixey', '0.8.1-1.tar.gz')
+        >>> file_to_package("foo-bar-1.2-py27-none-any.whl")
+        ('foo-bar', '1.2-py27-none-any.whl')
+        >>> file_to_package("Cython-0.17.2-cp26-none-linux_x86_64.whl")
+        ('Cython', '0.17.2-cp26-none-linux_x86_64.whl')
+        >>> file_to_package("PyYAML-3.10-py2.7-macosx-10.7-x86_64.egg")
+        ('PyYAML', '3.10-py2.7-macosx-10.7-x86_64.egg')
+        >>> file_to_package("python_ldap-2.3.9-py2.7-macosx-10.3-fat.egg")
+        ('python-ldap', '2.3.9-py2.7-macosx-10.3-fat.egg')
+        >>> file_to_package("python_ldap-2.4.19-cp27-none-macosx_10_10_x86_64.whl")
+        ('python-ldap', '2.4.19-cp27-none-macosx_10_10_x86_64.whl')
+        >>> file_to_package("foo.whl")
+        Traceback (most recent call last):
+            ...
+        InvalidFilePackageName: unexpected file name: 'foo.whl' (not in 'pkg-name-version.xxx' format)
+        >>> file_to_package("foo.png")
+        Traceback (most recent call last):
+            ...
+        InvalidFilePackageName: unexpected file name: 'foo.png' (not in 'pkg-name-version.xxx' format)
+        """
+    file = os.path.basename(file)
+    file_ext = os.path.splitext(file)[1].lower()
+    if file_ext == ".egg":
+        name = egg_project_name(file)
+        split = (name, file[len(name)+1:])
+        to_safe_name = lambda x: x
+        to_safe_rest = lambda x: x
+    elif file_ext == ".whl":
+        bits = file.rsplit("-", 4)
+        split = (bits[0], "-".join(bits[1:]))
+        to_safe_name = safe_name
+        to_safe_rest = lambda x: x
+    else:
+        match = re.search(r"(?P<pkg>.*?)-(?P<rest>\d+.*)", file)
+        if not match:
+            raise InvalidFilePackageName(file, basedir)
+        split = (match.group("pkg"), match.group("rest"))
+        to_safe_name = safe_name
+        to_safe_rest = safe_name
+
+    if len(split) != 2 or not split[1]:
+        raise InvalidFilePackageName(file, basedir)
+
+    return (to_safe_name(split[0]), to_safe_rest(split[1]))
+
+
+def pip_run_command(pip_args):
+    check_call(["pip"] + pip_args)
+
+OS_HAS_SYMLINK = hasattr(os, "symlink")
+
+
+class Pip2PiOptionParser(optparse.OptionParser):
+    def format_description(self, formatter):
+        # Parent implementation reformats all the hard line breaks
+        return self.get_description() + "\n"
+
+    def add_index_options(self):
+        self.add_option(
+            '-n', '--normalize-package-names', dest="normalize_package_names",
+            default=True, action="store_true",
+            help=dedent("""
+                Normalize package names in the simple index using whatever
+                scheme is supported by the most recent version of pip (default).
+            """))
+        self.add_option(
+            '-N', '--no-normalize-package-names', dest="normalize_package_names",
+            action="store_false")
+        self.add_option(
+            '-a', '--aggressive-normalization', dest="aggressive_normalization",
+            default=False, action="store_true",
+            help=dedent("""
+                Aggressive create symlinks to many different package name
+                normalizations to support multiple pip versions (for a package
+                named "Spam_Eggs--cheese.shop", the following normalizations
+                will be used: "spam-eggs-cheese-shop" (PEP-503),
+                "spam-eggs-cheese.shop" (pip 6, pip 7),
+                "Spam_Eggs--cheese.shop" (pip < 6)).
+            """))
+        self.add_option(
+            '--recursive', dest="recursive", default=True, action="store_true",
+            help=dedent("""
+                Also scan sub-directories of PACKAGE_DIR, at any depth, for
+                packages (default). Files in sub-directories are only indexed
+                when their name ends in one of: .whl, .egg, .zip, .tgz, .tar,
+                .tar.gz, .tar.bz2, .tar.xz.
+            """))
+        self.add_option(
+            '--no-recursive', dest="recursive", action="store_false",
+            help=dedent("""
+                Only look at the top level of PACKAGE_DIR.
+            """))
+        self.add_option(
+            '-x', '--no-build-html', dest="build_html", action="store_false",
+            default=True, help=dedent("""
+                Don't build index files for each directory, you might want to
+                to disable this if your server dynamically builds index files
+                using something like mod_autoindex and you want to make older
+                package/module versions continue to be available.
+            """))
+        self.add_option(
+            '-z', '--also-get-source', dest="get_source", action="store_true",
+            default=False, help=dedent("""
+                In addition to downloading wheels, eggs or any other package
+                format also download the source tar.gz files in case the
+                platform using this index does not support the wheel/egg/etc
+            """))
+        self.add_option(
+            '-s', '--symlink', dest="use_symlink",
+            default=OS_HAS_SYMLINK, action="store_true",
+            help=dedent("""
+                Use symlinks in PACKAGE_DIR/simple/ rather than copying files.
+                Default: %default
+            """))
+        self.add_option(
+            '-S', '--no-symlink', dest="use_symlink", action="store_false")
+        self.add_option(
+            '-v', '--verbose', dest="verbose", action="store_true")
+
+    def _process_args(self, largs, rargs, values):
+        """
+        An unknown option pass-through implementation of OptionParser.
+
+        When unknown arguments are encountered, bundle with largs and try again,
+        until rargs is depleted.
+
+        sys.exit(status) will still be called if a known argument is passed
+        incorrectly (e.g. missing arguments or bad argument types, etc.)
+
+        From http://stackoverflow.com/a/9307174/6364
+        """
+        while rargs:
+            try:
+                optparse.OptionParser._process_args(self, largs, rargs, values)
+            except (optparse.BadOptionError, optparse.AmbiguousOptionError) as e:
+                largs.append(e.opt_str)
+
+
+def dir2pi(argv=sys.argv, use_symlink=None):
+    parser = Pip2PiOptionParser(
+        usage="usage: %prog PACKAGE_DIR",
+        description=dedent("""
+            Creates the directory PACKAGE_DIR/simple/ and populates it with the
+            directory structure required to use with pip's --index-url.
+
+            Assumes that PACKAGE_DIR (and, unless --no-recursive is given, its
+            sub-directories) contain a bunch of archives named
+            'package-name-version.ext' (ex 'foo-2.1.tar.gz' or
+            'foo-bar-1.3rc1.bz2').
+
+            This makes the most sense if PACKAGE_DIR is somewhere inside a
+            webserver's htdocs directory.
+
+            For example:
+
+                $ ls packages/
+                foo-1.2.tar.gz
+                $ dir2pi packages/
+                $ find packages/
+                packages/
+                packages/foo-1.2.tar.gz
+                packages/simple/
+                packages/simple/foo/
+                packages/simple/foo/index.html
+                packages/simple/foo/foo-1.2.tar.gz
+        """))
+
+    if use_symlink is not None:
+        warnings.warn("dir2pi(use_symlink=...) is deprecated", stacklevel=1)
+
+    parser.add_index_options()
+
+    option, argv = parser.parse_args(argv)
+    if option.aggressive_normalization and not option.use_symlink:
+        sys.stderr.write(
+            "Error: cannot use --aggressive-normalization without --symlink\n")
+        return 1
+
+    if len(argv) != 2:
+        parser.print_help()
+        parser.exit()
+    return _dir2pi(option, argv)
+
+def normalize_pep503(pkg_name):
+    # As per https://www.python.org/dev/peps/pep-0503/#normalized-names
+    return re.sub(r"[-_.]+", "-", pkg_name).lower()
+
+def normalize_pip67(pkg_name):
+    # Normalize for pip 6 and 7
+    return re.sub(r"([-.])+", r"\1", pkg_name.replace("_", "-")).lower()
+
+def try_symlink(option, source, target):
+    try:
+        os.symlink(source, target)
+        if option.verbose:
+            print('linking %s to %s' %(source, target))
+    except OSError as e:
+        if e.errno == 17:
+            # ignore errors when the file exists
+            return
+        sys.stderr.write(
+            'ERROR linking %s to %s (skipping): %s\n'
+            %(source, target, e)
+        )
+
+
+# Files in sub-directories are only treated as packages when their name looks
+# like a package archive: a directory full of downloads often also holds a
+# README, an index.html, etc. The top level keeps the historical behaviour of
+# treating every file it finds as a package.
+PACKAGE_FILE_EXTS = (
+    ".whl", ".egg", ".zip", ".tgz", ".tar", ".tar.gz", ".tar.bz2", ".tar.xz",
+)
+
+def is_package_file(filename):
+    return filename.lower().endswith(PACKAGE_FILE_EXTS)
+
+
+def iter_package_files(pkgdir, recursive=True, skip_dirs=()):
+    """ Yields the packages to index, depth first.
+
+        The top level of ``pkgdir`` is always scanned. Sub-directories are
+        scanned too when ``recursive`` is true (the default), but only files
+        that look like a package archive are taken from them. Hidden files and
+        directories are ignored, and so is anything in ``skip_dirs`` (absolute
+        paths -- the generated ``simple`` directory).
+    """
+    skip_dirs = set(os.path.abspath(x) for x in skip_dirs)
+    if not recursive:
+        for filename in sorted(os.listdir(pkgdir)):
+            filepath = os.path.join(pkgdir, filename)
+            if not filename.startswith(".") and os.path.isfile(filepath):
+                yield filepath
+        return
+
+    for dirpath, dirnames, filenames in os.walk(pkgdir):
+        at_top = os.path.abspath(dirpath) == os.path.abspath(pkgdir)
+        dirnames[:] = sorted(
+            dirname for dirname in dirnames
+            if not dirname.startswith(".")
+            and os.path.abspath(os.path.join(dirpath, dirname)) not in skip_dirs
+        )
+        for filename in sorted(filenames):
+            if filename.startswith("."):
+                continue
+            if not at_top and not is_package_file(filename):
+                continue
+            filepath = os.path.join(dirpath, filename)
+            if os.path.isfile(filepath):
+                yield filepath
+
+
+def _dir2pi(option, argv):
+    pkgdir = argv[1]
+    if not os.path.isdir(pkgdir):
+        raise ValueError("no such directory: %r" %(pkgdir, ))
+    pkgdirpath = lambda *x: os.path.join(pkgdir, *x)
+
+    shutil.rmtree(pkgdirpath("simple"), ignore_errors=True)
+    os.mkdir(pkgdirpath("simple"))
+    pkg_index = ("<html><head><title>Simple Index</title>"
+                 "<meta name='api-version' value='2' /></head><body>\n")
+
+    # The same archive can be present more than once -- nightly builds keep a
+    # directory per build -- and only one of them is indexed: the last one in
+    # lexicographic order, so the newest build directory wins.
+    pkg_files = {}
+    for pkg_filepath in iter_package_files(
+        pkgdir,
+        recursive=option.recursive,
+        skip_dirs=[pkgdirpath("simple")],
+    ):
+        pkg_basename = os.path.basename(pkg_filepath)
+        pkg_name, pkg_rest = file_to_package(
+            pkg_basename, os.path.dirname(pkg_filepath),
+        )
+
+        pkg_dir_name = pkg_name
+        if option.normalize_package_names:
+            pkg_dir_name = normalize_pep503(pkg_dir_name)
+
+        pkg_key = (pkg_dir_name, pkg_basename)
+        previous = pkg_files.get(pkg_key)
+        if previous is None or (
+            os.path.normpath(pkg_filepath) > os.path.normpath(previous[0])
+        ):
+            if previous is not None and option.verbose:
+                print('replacing duplicate %s with %s' %(
+                    previous[0], pkg_filepath,
+                ))
+            pkg_files[pkg_key] = (pkg_filepath, pkg_name)
+        elif option.verbose:
+            print('ignoring duplicate %s (keeping %s)' %(
+                pkg_filepath, previous[0],
+            ))
+
+    processed_pkg = set()
+    written_pkg_pages = set()
+    index_links = []
+    for (pkg_dir_name, pkg_basename), (pkg_filepath, pkg_name) in pkg_files.items():
+        pkg_dir = pkgdirpath("simple", pkg_dir_name)
+        if not os.path.exists(pkg_dir):
+            os.mkdir(pkg_dir)
+
+        if option.aggressive_normalization:
+            try_symlink(option, pkg_dir_name, pkgdirpath("simple", normalize_pip67(pkg_name)))
+            try_symlink(option, pkg_dir_name, pkgdirpath("simple", pkg_name))
+
+        symlink_target = os.path.join(pkg_dir, pkg_basename)
+        symlink_source = os.path.relpath(pkg_filepath, pkg_dir)
+        if option.use_symlink:
+            try_symlink(option, symlink_source, symlink_target)
+        else:
+            if option.verbose:
+                print('copying %s to %s' % (symlink_target, pkg_filepath))
+            shutil.copy2(pkg_filepath, symlink_target)
+
+        if pkg_name not in processed_pkg:
+            index_links.append((pkg_dir_name, pkg_name))
+            processed_pkg.add(pkg_name)
+
+        if option.build_html:
+            pkg_page = os.path.join(pkg_dir, "index.html")
+            if pkg_page not in written_pkg_pages:
+                with open(pkg_page, "w") as fp:
+                    fp.write(
+                        "<html><head><title>Links for %(name)s</title>"
+                        "<meta name='api-version' value='2' />"
+                        "</head><body>\n"
+                        "<h1>Links for %(name)s</h1>\n" %{
+                            "name": escape(pkg_name),
+                        }
+                    )
+                written_pkg_pages.add(pkg_page)
+            with open(pkg_page, "a") as fp:
+                fp.write("<a href='%(name)s'>%(name)s</a><br />\n" %{
+                    "name": escape(pkg_basename),
+                })
+    # The order in which the archives are found depends on the filesystem (and
+    # on the directory they live in), so the index is sorted here rather than
+    # relying on the order of the scan: alphabetically, ignoring case.
+    pkg_index += "".join(
+        "<a href='%(dir)s/'>%(name)s</a><br />\n" %{
+            "dir": escape(pkg_dir_name),
+            "name": escape(pkg_name),
+        }
+        for pkg_dir_name, pkg_name in sorted(
+            index_links, key=lambda link: (link[1].lower(), link[1]),
+        )
+    )
+    pkg_index += "</body></html>\n"
+
+    if option.build_html:
+        with open(pkgdirpath("simple/index.html"), "w") as fp:
+            fp.write(pkg_index)
+        for pkg_page in written_pkg_pages:
+            with open(pkg_page, "a") as fp:
+                fp.write("</body></html>\n")
+
+    return 0
+
+def globall(globs):
+    result = []
+    for g in globs:
+        result.extend(glob.glob(g))
+    return result
+
+@maintain_cwd
+def pip2tgz(argv=sys.argv):
+    glob_exts = ['*.whl', '*.tgz', '*.gz']
+    parser = Pip2PiOptionParser(
+        usage="usage: %prog OUTPUT_DIRECTORY [PIP_OPTIONS] PACKAGES ...",
+        description=dedent("""
+            Where PACKAGES are any names accepted by pip (ex, `foo`,
+            `foo==1.2`, `-r requirements.txt`), and [PIP_OPTIONS] can be any
+            options accepted by `pip %s`.
+
+            pip2tgz will download all packages required to install PACKAGES and
+            save them to sanely-named tarballs or wheel files in OUTPUT_DIRECTORY.
+
+            For example:
+
+                $ pip2tgz /var/www/packages/ -r requirements.txt foo==1.2 baz/
+                $ pip2tgz /var/www/packages/ \\
+                    %s \\
+                    --index-url https://example.com/simple \\
+                    bar==3.1
+        """ % (pip_download_command, pip_no_binary_command)))
+
+    option, argv = parser.parse_args(argv)
+    if len(argv) < 3:
+        parser.print_help()
+        parser.exit()
+
+    outdir = os.path.abspath(argv[1])
+    if not os.path.exists(outdir):
+        os.mkdir(outdir)
+
+    full_glob_paths = [
+        os.path.join(outdir, g) for g in glob_exts
+    ]
+    pkg_file_set = lambda: set(globall(full_glob_paths))
+    old_pkgs = pkg_file_set()
+
+    pip_run_command(pip_download_command.split() + [outdir] + argv[2:])
+
+    os.chdir(outdir)
+    new_pkgs = pkg_file_set() - old_pkgs
+    num_pkgs = len(pkg_file_set() - old_pkgs)
+    print("\nDone. %s new archives currently saved in %r." %(num_pkgs, argv[1]))
+    return 0
+
+
+WINDOWS_PATH_RE = re.compile(r"^[A-Za-z]:\\")
+
+def is_remote_target(target):
+    return ":" in target and not WINDOWS_PATH_RE.match(target)
+
+
+def pip2pi(argv=sys.argv):
+    parser = Pip2PiOptionParser(
+        usage="usage: %prog TARGET [PIP_OPTIONS] PACKAGES ...",
+        description=dedent("""
+            Adds packages PACKAGES to PyPI-compatible package index at TARGET.
+
+            If TARGET contains ':' it will be treated as a remote path. The
+            package index will be built locally and rsync will be used to copy
+            it to the remote host.
+
+            PIP_OPTIONS can be any options accepted by `pip %s`, like
+            `--index-url` or `%s`.
+
+            For example, to create a remote index:
+
+                $ pip2pi example.com:/var/www/packages/ -r requirements.txt
+
+            To create a local index:
+
+                $ pip2pi ~/Sites/packages/ foo==1.2
+
+            To pass arguments to pip:
+
+                $ pip2pi ~/Sites/packages/ \\
+                    %s \\
+                    --index-url https://example.com/simple \\
+                    -r requirements-base.txt \\
+                    -r requirements-dev.txt \\
+                    bar==3.1
+
+        """ % (pip_download_command, pip_no_binary_command, pip_no_binary_command)))
+    parser.add_index_options()
+
+    option, argv = parser.parse_args(argv)
+    if len(argv) < 3:
+        parser.print_help()
+        parser.exit()
+
+    target = argv[1]
+    pip_argv = argv[2:]
+    if is_remote_target(target):
+        is_remote = True
+        working_dir = tempfile.mkdtemp(prefix="pip2pi-working-dir")
+        atexit.register(lambda: shutil.rmtree(working_dir))
+    else:
+        is_remote = False
+        working_dir = os.path.abspath(target)
+
+    subcmd_argv = [argv[0], working_dir] + pip_argv
+    res = pip2tgz(subcmd_argv)
+    if res:
+        print("pip2tgz returned an error; aborting.")
+        return res
+    if option.get_source:
+        subcmd_argv_source = subcmd_argv[:]
+        subcmd_argv_source.insert(2, pip_no_binary_command)
+        res = pip2tgz(subcmd_argv_source)
+        if res:
+            print("pip2tgz returned an error; aborting.")
+            return res
+
+    res = _dir2pi(option, subcmd_argv)
+    if res:
+        print("dir2pi returned an error; aborting.")
+        return res
+
+    if is_remote:
+        print("copying temporary index at %r to %r..." %(working_dir, target))
+        check_call([
+            "rsync",
+            "--recursive", "--progress", "--links",
+            working_dir + "/", target + "/",
+        ])
+    return 0

pip2pi_dev-0.9.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: pip2pi-dev
+Version: 0.9.0
+Summary: pip2pi builds a PyPI-compatible package repository from pip requirements
+Author-email: David Wolever <david@wolever.net>
+Maintainer-email: Md Safiyat Reza <safiyat@voereir.com>
+License-Expression: BSD-2-Clause
+Project-URL: Homepage, https://github.com/wolever/pip2pi
+Keywords: pypi,mirror,offline,package index,pip
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: pip>=10.0.0
+Dynamic: license-file
+
+``pip2pi`` builds a PyPI-compatible package repository from ``pip`` requirements
+================================================================================
+
+PyPI can go down, package maintainers can remove old tarballs, and downloading
+tarballs can take a long time. ``pip2pi`` helps to alleviate these problems by
+making it blindingly simple to maintain a PyPI-compatible repository of packages
+your software depends on.
+
+::
+
+    $ pip2pi --help
+    Usage: pip2pi TARGET [PIP_OPTIONS] PACKAGES ...
+
+    Adds packages PACKAGES to PyPI-compatible package index at TARGET.
+
+    If TARGET contains ':' it will be treated as a remote path. The
+    package index will be built locally and rsync will be used to copy
+    it to the remote host.
+
+    PIP_OPTIONS can be any options accepted by `pip install -d`, like
+    `--index-url` or `--no-use-wheel`.
+
+    For example, to create a remote index:
+
+        $ pip2pi example.com:/var/www/packages/ -r requirements.txt
+
+    To create a local index:
+
+        $ pip2pi ~/Sites/packages/ foo==1.2
+
+    To pass arguments to pip:
+
+        $ pip2pi ~/Sites/packages/ \
+            --index-url https://example.com/simple \
+            --no-use-wheel \
+            -r requirements-base.txt \
+            -r requirements-dev.txt \
+            bar==3.1
+
+
+Requirements
+------------
+
+0. Python 3.11 or newer
+1. ``pip``
+2. A ``requirements.txt`` file for your project (optional, but useful)
+3. An HTTP server (optional, but useful)
+
+
+Setup
+-----
+
+Install ``pip2pi``::
+
+    $ pip install pip2pi
+
+And create the directory which will contain the tarballs of required packages,
+preferably somewhere under your web server's document root::
+
+    $ mkdir /var/www/packages/
+
+
+Mirroring Packages
+------------------
+
+To mirror a package and all of its requirements, use ``pip2tgz``::
+
+    $ pip2tgz packages/ foo==1.2
+    ...
+    $ ls packages/
+    foo-1.2.tar.gz
+    bar-0.8.tar.gz
+
+Note that ``pip2tgz`` passes package arguments directly to ``pip``, so packages
+can be specified in any format that ``pip`` recognizes::
+
+    $ cat requirements.txt
+    foo==1.2
+    http://example.com/baz-0.3.tar.gz
+    $ pip2tgz packages/ -r requirements.txt bam-2.3/
+    ...
+    $ ls packages/
+    foo-1.2.tar.gz
+    bar-0.8.tar.gz
+    baz-0.3.tar.gz
+    bam-2.3.tar.gz
+
+
+Building a Package Index
+------------------------
+
+A directory full of ``.tar.gz`` files can be turned into PyPI-compatible
+"simple" package index using the ``dir2pi`` command::
+
+    $ ls packages/
+    bar-0.8.tar.gz
+    baz-0.3.tar.gz
+    foo-1.2.tar.gz
+    $ dir2pi packages/
+    $ find packages/
+    packages/
+    packages/bar-0.8.tar.gz
+    packages/baz-0.3.tar.gz
+    packages/foo-1.2.tar.gz
+    packages/simple
+    packages/simple/bar
+    packages/simple/bar/bar-0.8.tar.gz
+    packages/simple/baz
+    packages/simple/baz/baz-0.3.tar.gz
+    packages/simple/foo
+    packages/simple/foo/foo-1.2.tar.gz
+
+The archives do not have to sit at the top level of ``packages/``: unless
+``--no-recursive`` is given, every sub-directory is scanned too, and only
+files named like a package archive (``.whl``, ``.egg``, ``.zip``, ``.tgz``,
+``.tar``, ``.tar.gz``, ``.tar.bz2``, ``.tar.xz``) are picked up from them::
+
+    $ find packages/ -name '*.whl'
+    packages/flask/flask-3.1.3-py3-none-any.whl
+    packages/click/v8.5.0/click-8.5.0-py3-none-any.whl
+    $ dir2pi packages/
+
+If the same archive (same file name) is present in more than one place -- as
+happens with nightly builds, kept in a directory per build -- it is indexed
+once, using the last one in lexicographic order.
+
+
+But that's a lot of work...
+---------------------------
+
+If running two commands seems like too much work... Take heart! The ``pip2pi``
+command will run both of them for you... **And** it will use ``rsync`` to copy
+the new packages and index to a remote host! ::
+
+    $ pip2pi example.com:/var/www/packages/ foo==1.2
+    ...
+    $ curl -I http://example.com/packages/simple/foo/foo-1.2.tar.gz | head -n1
+    HTTP/1.1 200 OK
+
+
+But that's still too much work...
+.................................
+
+Take heart! Your shell's ``alias`` command can help. Add an alias like this to
+your shell's runtime configuration file (hint: ``~/.bashrc`` or similar)::
+
+    alias pip2acmeco="pip2pi dev.acmeco.com:/var/www/packages/"
+
+Now updating your package index will be as simple as::
+
+    $ pip2acmeco foo==1.2 -r bar/requirements.txt
+
+
+Using Your New Package Index
+----------------------------
+
+To use the new package index, pass the ``--index-url=`` argument to ``pip``::
+
+    $ pip install --index-url=http://example.com/packages/simple/ foo
+
+Or, once it has been mirrored, prefix you ``requirements.txt`` with
+``--index-url=...``::
+
+    $ cat requirements.txt
+    --index-url=http://example.com/packages/simple/
+    foo==1.2
+
+
+Without a web server
+--------------------
+
+You can use your package index offline, too::
+
+    $ pip install --index-url=file:///var/www/packages/simple foo==1.2
+
+
+Some Tips
+---------
+
+When installing packages from source via ``python setup.py install`` or
+``python setup.py install``, you may need to create a ``setup.cfg``, which
+points to your package index.  Here are some examples for an offline package
+index in your Windows, Linux, or Mac file system::
+    
+    [easy_install]
+    # Windows
+    # index_url = file:///C:/pip2pi/simple/
+
+    # Linux
+    # index_url = file:///home/myusername/.pip2pi/simple/
+
+    # Mac
+    index_url = file:///Users/myusername/.pip2pi/simple/
+    
+Note the triple ``///`` after ``file:`` -- two for the protocol,
+the third for the root of the local file system.
+
+
+Building and releasing
+----------------------
+
+The wheel is built with `uv <https://docs.astral.sh/uv/>`_. Locally::
+
+    $ uv build --wheel
+    $ ls dist/
+    dist/pip2pi_dev-0.9.0-py3-none-any.whl
+
+Two GitHub Actions workflows share the work: ``.github/workflows/test.yml`` runs
+the test suite on every push and pull request, and
+``.github/workflows/publish.yml`` builds the wheel with uv and publishes it to
+PyPI when a version tag is pushed::
+
+    $ git tag v0.9.0
+    $ git push origin v0.9.0
+
+The tag must match ``libpip2pi.__version__``. A manual run of ``publish.yml``
+can publish to TestPyPI (or to PyPI) without tagging, or just build the wheel.
+The two workflows are independent, so only tag a commit whose tests are green.
+Publishing uses trusted publishing when it is configured for this repository on
+PyPI (workflow ``publish.yml``, environment ``pypi``), otherwise the
+``PYPI_API_TOKEN`` secret (``TEST_PYPI_API_TOKEN`` for TestPyPI).
+
+
+Keywords
+========
+
+* Mirror PyPI
+* Offline PyPI
+* Create offline PyPI mirror

pip2pi_dev-0.9.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+libpip2pi/__init__.py,sha256=gQN1WAxqYmHO6KwIyhBVtLCC-RMVLc-gPIaHx4V4OyE,24
+libpip2pi/commands.py,sha256=IPp3OHtMUQ44lC1pC4l60nLj8kP_wkRnINXszpRPe3o,21978
+pip2pi_dev-0.9.0.dist-info/licenses/LICENSE.txt,sha256=3p5Bye0lYadUXzOcVsryrKzo-mXtJJaMaTv8bfAvwGU,1649
+pip2pi_dev-0.9.0.dist-info/METADATA,sha256=o4deB0zMkfCn6tGx-M78aUEqE5rA9KHjMoTYi7GfXoc,7714
+pip2pi_dev-0.9.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pip2pi_dev-0.9.0.dist-info/entry_points.txt,sha256=KuDQoTc_gN24UyyRfQo1HGWl2J2PU4u2ET9vV_KzxFQ,125
+pip2pi_dev-0.9.0.dist-info/top_level.txt,sha256=c7EW__NGhQIdxV9AbKti_A6JqTzW62f0_DrYDPIbUoY,10
+pip2pi_dev-0.9.0.dist-info/RECORD,,

pip2pi_dev-0.9.0.dist-info/WHEEL

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

pip2pi_dev-0.9.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+dir2pi = libpip2pi.commands:dir2pi
+pip2pi = libpip2pi.commands:pip2pi
+pip2tgz = libpip2pi.commands:pip2tgz

pip2pi_dev-0.9.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,29 @@
+tl;dr: all code code is licensed under simplified BSD, unless stated otherwise.
+
+Unless stated otherwise in the source files, all code is copyright 2010 David
+Wolever <david@wolever.net>. 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 <COPYRIGHT HOLDER> ``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 <COPYRIGHT HOLDER> 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 David Wolever.

pip2pi_dev-0.9.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+libpip2pi