bundle-deps 0.1.0__py3-none-any.whl

bundle_deps/__init__.py

@@ -0,0 +1 @@
+"""Package bundling tool."""

bundle_deps/__main__.py

@@ -0,0 +1,4 @@
+from bundle_deps.cli import main
+
+if __name__ == "__main__":
+    main()

bundle_deps/archive.py

@@ -0,0 +1,36 @@
+import os
+import tarfile
+
+
+def create_bundle_archive(source_dir, output_file):
+    """
+        The function takes the directory that contains
+        the dependencies and zip it into a bundle
+    """
+    try:
+        # create a gz gile
+        with tarfile.open(output_file, "w:gz") as tar:
+            # add the dir 
+            tar.add(source_dir, arcname=os.path.basename(source_dir))
+    except (tarfile.TarError, OSError) as error:
+        raise RuntimeError(
+            f"Failed to create bundle archive: {source_dir}"
+        ) from error
+
+
+def create_dependencies_archive(source_dir, output_file):
+    """
+        The function creates an archive of every dependency
+    """
+    try:
+        # create a new gz fie and add all of the files in the dir
+        with tarfile.open(output_file, "w:gz") as tar:
+            for file in os.listdir(source_dir):
+                file_path = os.path.join(source_dir, file)
+                tar.add(file_path, arcname=file)
+    except (tarfile.TarError, OSError) as error:
+        raise RuntimeError(
+            f"Failed to create dependencies archive: {source_dir}"
+        ) from error
+        
+    print(f"Dependencies archive created: {output_file}")

bundle_deps/cli.py

@@ -0,0 +1,34 @@
+import argparse
+
+from bundle_deps.export import export_project
+
+
+def create_parser():
+    """
+        The function creates the parser for the flags of the cli tool
+    """
+
+    parser = argparse.ArgumentParser(description="Package bundling tool")
+    parser.add_argument("project_path", help="Path to project directory")
+    parser.add_argument("--commit-sha" , help="Commit SHA to compare current dependencies against")
+    parser.add_argument("--latest-commit", action="store_true", help="Get the latest Commit SHA to compare current dependencies against")
+    parser.add_argument("--verbose","-v" ,action="store_true", help="Print each dependency as it is downloaded instead of showing a progress bar")
+    parser.add_argument("--manylinux", action="store_true", help="Download only manylinux wheels (plus pure python wheels) for uv dependencies")
+    parser.add_argument("--no-pack", action="store_true", help="Does not pack the dependencies in .tar.gz")
+    parser.add_argument("--bundle-name", help="Allows to choose the bundle name")
+    parser.add_argument("--output-dir", help="Allows to choose the output dir for the bundle")
+    
+    return parser
+
+
+def main():
+
+    # creates the parser and get the args
+    parser = create_parser()
+    args = parser.parse_args()
+    try:
+        export_project(args.project_path, args.commit_sha, args.latest_commit, args.manylinux, args.verbose, args.no_pack, args.bundle_name, args.output_dir)
+
+    except (FileNotFoundError, NotADirectoryError, RuntimeError) as error:
+        print(f"error: {error}")
+        raise SystemExit(1)

bundle_deps/download.py

@@ -0,0 +1,202 @@
+import os
+import requests
+import tqdm
+from concurrent.futures import ThreadPoolExecutor
+
+DOWNLOAD_WORKERS = 8
+
+
+def download_file_with_progress(url, file_path):
+    """
+    Downloads a single file from url to file_path (no per-file progress bar).
+    """
+    with requests.get(url, stream=True, timeout=30) as response:
+        response.raise_for_status()
+        block_size = 1024  # 1 KB
+
+        with open(file_path, "wb") as file:
+            for chunk in response.iter_content(chunk_size=block_size):
+                if chunk:
+                    file.write(chunk)
+
+
+def download_dependencies(dependencies, output_dir, plan_files, desc, exists_set=None, verbose=False):
+    """
+        The function runs the shared download pipeline for any ecosystem.
+
+        plan_files(dependency) decides what a single dependency needs and returns
+        (files, skips, failed):
+            files   - list of (url, filename, label) to download, or None to skip
+                      the dependency without counting it as a failure
+            skips   - messages to report as skipped
+            failed  - True when the dependency is already broken before downloading
+    """
+
+    if exists_set is None:
+        exists_set = set()
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    failed_dependencies = []
+    skipped = []
+    errors = []
+
+    def download_one(dependency):
+        """Returns (package, success) or None if skipped"""
+        package = f"{dependency['name']}@{dependency['version']}"
+
+        if package in exists_set:
+            skipped.append(f"{package} - already exists")
+            return None
+
+        files, skips, dependency_failed = plan_files(dependency)
+
+        skipped.extend(skips)
+
+        # the dependency has nothing to download and is not treated as a failure
+        if files is None:
+            return None
+
+        for url, filename, label in files:
+
+            file_path = os.path.join(output_dir, filename)
+
+            try:
+                if verbose:
+                    print(f"Downloading: {label}", flush=True)
+                download_file_with_progress(url, file_path)
+            except requests.RequestException as error:
+                errors.append(f"{package}: {error}")
+                dependency_failed = True
+
+        return package, not dependency_failed
+
+    with ThreadPoolExecutor(max_workers=DOWNLOAD_WORKERS) as executor:
+        results = executor.map(download_one, dependencies)
+        if not verbose:
+            results = tqdm.tqdm(
+                results,
+                total=len(dependencies),
+                desc=desc,
+                unit="pack",
+            )
+        for result in results:
+            if result is None:
+                continue
+            package, success = result
+            if success:
+                exists_set.add(package)
+            else:
+                failed_dependencies.append(package)
+
+    for item in skipped:
+        print(f"Skipped: {item}")
+    for item in errors:
+        print(f"Failed: {item}")
+
+    if failed_dependencies:
+        raise RuntimeError(
+            "Failed to download dependencies: "
+            + ", ".join(failed_dependencies)
+        )
+
+
+def plan_npm_files(dependency):
+    """
+        The function decides which file a single npm dependency needs
+    """
+
+    url = dependency.get("resolved")
+
+    # without a URL there is nothing to download, but it is not a failure
+    if not url:
+        return None, [f"{dependency['name']} - no URL"], False
+
+    package = f"{dependency['name']}@{dependency['version']}"
+
+    filename = (
+        dependency["name"].replace("/", "_")
+        + "-"
+        + dependency["version"]
+        + ".tgz"
+    )
+
+    return [(url, filename, package)], [], False
+
+
+def plan_uv_files(dependency, output_dir, manylinux=False):
+    """
+        The function decides which wheels and sdist a single uv dependency needs
+    """
+
+    package = f"{dependency['name']}@{dependency['version']}"
+
+    files = []
+    skips = []
+    dependency_failed = False
+
+    for wheel in dependency.get("wheels", []):
+
+        url = wheel.get("url")
+
+        if not url:
+            skips.append(f"{package} - no URL")
+            dependency_failed = True
+            continue
+
+        filename = os.path.basename(url)
+
+        # with the manylinux flag, skip platform wheels that aren't manylinux
+        # (pure python "any" wheels are still needed)
+        if manylinux and "manylinux" not in filename and not filename.endswith("-any.whl"):
+            skips.append(f"{filename} - not manylinux")
+            continue
+
+        files.append((url, filename, filename))
+
+    sdist = dependency.get("sdist")
+
+    if sdist:
+        url = sdist.get("url")
+
+        if url:
+            filename = os.path.basename(url)
+
+            # the sdist is skipped when a wheel already produced the same file
+            if not os.path.exists(os.path.join(output_dir, filename)):
+                files.append((url, filename, filename))
+
+    return files, skips, dependency_failed
+
+
+def download_npm_dependencies(dependencies, output_dir, exists_set=None, verbose=False):
+    """
+        The function downloads the npm dependencies from the dependencies list
+    """
+
+    return download_dependencies(
+        dependencies,
+        output_dir,
+        plan_npm_files,
+        "Downloading npm",
+        exists_set,
+        verbose,
+    )
+
+
+def download_uv_dependencies(dependencies, output_dir, exists_set=None, manylinux=False, verbose=False):
+    """
+        The function downloads the uv dependencies from the dependencies list
+    """
+
+    def plan(dependency):
+        return plan_uv_files(dependency, output_dir, manylinux)
+
+    return download_dependencies(
+        dependencies,
+        output_dir,
+        plan,
+        "Downloading uv",
+        exists_set,
+        verbose,
+    )

bundle_deps/export.py

@@ -0,0 +1,120 @@
+import os
+import shutil
+from datetime import datetime
+
+from bundle_deps.utils import runtime_count, temporary_directory, validate_project_path
+from bundle_deps.locks import (
+    find_lock_files,
+    gather_npm_dependencies_from_locks,
+    gather_uv_dependencies_from_lockfiles,
+)
+from bundle_deps.download import download_npm_dependencies, download_uv_dependencies
+from bundle_deps.archive import create_bundle_archive, create_dependencies_archive
+from bundle_deps.git_source import get_git_url, fetch_git_by_sha
+
+COMMIT_SHA = os.getenv("GITHUB_SHA") or "example-sha"
+
+
+@runtime_count
+def export_project(project_path, commit_sha=None, latest_commit=False, manylinux=False, verbose=False, no_pack=False, bundle_name = None, output_dir=None):
+    """
+        The function handles the export flow from getting the dependencies
+        from the lockfiles to downloading it and creating a bundle
+    """
+    
+    # check if the projects path exists or a dir
+    project_path = validate_project_path(project_path)
+
+    # get all the paths of the lock files
+    npm_lock_files, uv_lock_files = find_lock_files(project_path)
+
+    # if theres no lock files stop
+    if not npm_lock_files and not uv_lock_files:
+        print("No lock files found")
+        return
+
+    # get the timestamp for the bundle name
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    if bundle_name is None:
+        bundle_name = f"{timestamp}-{COMMIT_SHA}"
+
+    # gather all of the dependencies from lockfiles
+    npm_dependencies, _ = gather_npm_dependencies_from_locks(npm_lock_files)
+    uv_dependencies, _ = gather_uv_dependencies_from_lockfiles(uv_lock_files)
+
+    # every dependency is downloaded into a temp dir that is removed at the end
+    with temporary_directory() as temp_dir:
+
+        bundle_dir = os.path.join(temp_dir, bundle_name)
+
+        # make paths for seperate dirs for uv and npm
+        npm_dir = os.path.join(bundle_dir, "npm")
+        uv_dir = os.path.join(bundle_dir, "uv")
+
+        if commit_sha or latest_commit:
+
+            # clone the git repo from a specific sha into its own temp dir
+            with temporary_directory() as git_temp_dir:
+
+                git_path = os.path.join(git_temp_dir, "remote_git")
+
+                # clone the git repo of the specific sha
+                fetch_git_by_sha(get_git_url(), commit_sha, latest_commit, git_path)
+
+                # get lock files
+                git_npm_lock_files, git_uv_lock_files = find_lock_files(git_path)
+
+                # gather all of the dependencies in
+                _, git_npm_set = gather_npm_dependencies_from_locks(git_npm_lock_files)
+                _, git_uv_set = gather_uv_dependencies_from_lockfiles(git_uv_lock_files)
+
+            # download only the dependencies that the old commit does not have
+            download_npm_dependencies(npm_dependencies, npm_dir, git_npm_set, verbose=verbose)
+            download_uv_dependencies(uv_dependencies, uv_dir, git_uv_set, manylinux, verbose)
+        else:
+            # download all of the dependencies
+            download_npm_dependencies(npm_dependencies, npm_dir, verbose=verbose)
+            download_uv_dependencies(uv_dependencies, uv_dir, manylinux=manylinux, verbose=verbose)
+
+        # if theres no uv dependencies remove the dir
+        if len(os.listdir(uv_dir)) == 0:
+            print("No uv dependencies required download")
+            os.rmdir(uv_dir)
+
+        #  if theres no npm dependencies remove the dir
+        if len(os.listdir(npm_dir)) == 0:
+            print("No npm dependencies required download")
+            os.rmdir(npm_dir)
+        else:
+            # create npm-dependencies.tgz
+            npm_archive = os.path.join(bundle_dir, "npm-dependencies.tgz")
+
+            create_dependencies_archive(npm_dir, npm_archive)
+
+            # remove original npm dir
+            shutil.rmtree(npm_dir)
+
+        if not os.listdir(bundle_dir):
+            print("No dependencies required download")
+            return
+
+        if no_pack:
+            # copy the dependencies out of the temp dir as a plain folder
+            output_path = os.path.join(output_dir or os.getcwd(), bundle_name)
+            shutil.copytree(bundle_dir, output_path, dirs_exist_ok=True)
+
+            print(f"Dependencies copied to: {output_path}")
+        else:
+            # pack the dependencies and copy the archive out of the temp dir
+            archive_path = os.path.join(temp_dir, f"{bundle_name}.tar.gz")
+            create_bundle_archive(bundle_dir, archive_path)
+
+            if output_dir is None:
+                output_path = os.path.join(os.getcwd(), f"{bundle_name}.tar.gz")
+            else:
+                os.makedirs(output_dir, exist_ok=True)
+                output_path = os.path.join(output_dir, f"{bundle_name}.tar.gz")
+
+            shutil.copy2(archive_path, output_path)
+
+            print(f"Bundle created: {output_path}")

bundle_deps/git_source.py

@@ -0,0 +1,51 @@
+import os
+import tarfile
+import subprocess
+
+from bundle_deps.utils import temporary_directory
+
+
+def get_git_url():
+    """Resolve the repo URL dynamically: CI env vars first, then the origin remote."""
+    server = os.getenv("GITHUB_SERVER_URL")
+    repo = os.getenv("GITHUB_REPOSITORY")
+    if server and repo:
+        return f"{server}/{repo}.git"
+    return subprocess.run(
+        ["git", "remote", "get-url", "origin"],
+        capture_output=True, text=True, check=True,
+    ).stdout.strip()
+
+
+def fetch_git_by_sha(git_url, commit_sha, latest_commit=False, git_path="remote_git"):
+    """
+        The function clones a repo from a git url and specific commit
+        into git_path
+    """
+
+    # the clone and the archive live in a temp dir that is removed at the end
+    with temporary_directory() as work_dir:
+
+        temp_git = os.path.join(work_dir, "temp_git")
+        repo_archive = os.path.join(work_dir, "repo.tar")
+
+        try:
+            # clone the repo and fetch the specific commit as an archive
+            subprocess.run(["git", "clone", "--no-checkout", git_url, temp_git],check=True)
+
+            commit_sha = "HEAD^" if latest_commit else commit_sha
+
+            print(f"Processing the commit: {commit_sha}")
+
+            subprocess.run(["git", "-C", temp_git, "archive", "--format=tar", commit_sha, "-o", repo_archive],check=True)
+
+            # make dir for the unzipped archive
+            os.makedirs(git_path, exist_ok=True)
+
+            # open the repo archive 
+            with tarfile.open(repo_archive, "r") as tar:
+                tar.extractall(git_path)
+        except subprocess.CalledProcessError as error:
+            raise RuntimeError(f"Failed to fetch git commit {commit_sha}") from error
+
+    return git_path

bundle_deps/locks.py

@@ -0,0 +1,152 @@
+import os
+import json
+import tomllib
+
+
+def find_lock_files(project_path):
+    """
+        The function finds all of the lock files in the project
+        and returns their paths
+    """
+    
+    # init lists for uv and npm locks paths
+    uv_lock_files = []
+    npm_lock_files = []
+
+    # recursive walk in the project dir in search of lock files
+    for root, dirs, files in os.walk(project_path):
+
+        # check each file 
+        for file in files:
+
+            # if file is package-lock or uv.lock append to list
+            if file == "package-lock.json":
+                npm_lock_files.append(os.path.join(root, file))
+
+            elif file == "uv.lock":
+                uv_lock_files.append(os.path.join(root, file))
+
+    return npm_lock_files, uv_lock_files
+
+
+def extract_npm_dependencies(lock_path):
+    """
+        The function takes the npm dependencies , their versions ,
+        integrity and url
+    """
+
+    # init list for the dependencies
+    dependencies = []
+    dependencies_set = set()
+
+    try:
+        # open the json file and load it into a dict
+        with open(lock_path, "r", encoding="utf-8") as file:
+            lock_data = json.load(file)
+    except (OSError, json.JSONDecodeError) as error:
+        raise RuntimeError(
+            f"Failed to read npm lock files: {lock_path}"
+        ) from error
+
+    # check each item in the dict
+    for path, info in lock_data["packages"].items():
+
+        # if the item doesnt start with node_modules skip
+        if "node_modules/" not in path:
+            continue
+
+        # split the name from the path
+        package_name = path.split("node_modules/")[-1]
+
+        # append the dependencies to the list
+        dependencies.append({
+            "name": package_name,
+            "version": info.get("version"),
+            "resolved": info.get("resolved"),
+            "integrity": info.get("integrity")
+        })
+        
+        dependencies_set.add(f"{package_name}@{info.get("version")}")
+
+    return dependencies , dependencies_set
+
+
+def extract_uv_dependencies(lock_path):
+    """
+        The function extracts uv dependencies from the lock file
+    """
+    
+    # init list for dependencies
+    dependencies = []
+    dependencies_set = set()
+    try:  
+
+        # open the uv.lock file and load it into a dict
+        with open(lock_path, "rb") as file:
+            lock_data = tomllib.load(file)
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        raise RuntimeError(
+            f"Failed to read uv lock files {lock_path}"
+        ) from error
+
+    # check each item in the dict
+    for package in lock_data.get("package", []):
+
+        # take the current package 
+        package_data = {
+            "name": package.get("name"),
+            "version": package.get("version"),
+            "wheels": package.get("wheels", []),
+            "sdist": package.get("sdist")
+        }
+
+        # append to the dependencies list
+        dependencies.append(package_data)
+        dependencies_set.add(f"{package.get("name")}@{package.get("version")}")
+
+    return dependencies , dependencies_set
+
+
+def gather_npm_dependencies_from_locks(lock_files):
+    """
+        The function takes a list of npm lock files and gather all of
+        the dependencies into a list and set
+    """
+    
+    npm_dependencies = []
+    npm_set = set()
+    
+    # gather the dependencies for each npm lockfile
+    for lock_file in lock_files:
+    
+        # print message and extract dependencies
+        print(f"Processing npm: {lock_file}")
+        dependencies, dependencies_set = extract_npm_dependencies(lock_file)
+        
+        # add the dependencies to the set and list
+        npm_dependencies.extend(dependencies)
+        npm_set.update(dependencies_set)
+        
+    return npm_dependencies, npm_set
+
+
+def gather_uv_dependencies_from_lockfiles(lock_files):
+    """
+        The function takes a list of uv lock files and gather all of
+        the dependencies into a list and set
+    """
+    
+    uv_dependencies = []
+    uv_set = set()
+    
+    for lock_file in lock_files:
+        
+        # print message and extract dependencies
+        print(f"Processing uv: {lock_file}")
+        dependencies, dependencies_set = extract_uv_dependencies(lock_file)
+        
+        # add the dependencies to the set and list
+        uv_dependencies.extend(dependencies)
+        uv_set.update(dependencies_set)
+        
+    return uv_dependencies, uv_set

bundle_deps/utils.py

@@ -0,0 +1,56 @@
+import os
+import shutil
+import stat
+import time
+import tempfile
+from functools import wraps
+from contextlib import contextmanager
+
+
+def runtime_count(func):
+    @wraps(func)
+    def count(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        print(f"Total time: {end_time - start_time:.2f} seconds")
+        return result
+    return count
+
+
+def remove_readonly(func, path, exc):
+    """
+        The function helps removing a full dir
+    """
+    os.chmod(path, stat.S_IWRITE)
+    func(path)
+
+
+@contextmanager
+def temporary_directory():
+    """
+        The function yields a temporary directory that is always removed on exit,
+        even when it holds read only files
+    """
+
+    path = tempfile.mkdtemp()
+    try:
+        yield path
+    finally:
+        shutil.rmtree(path, onexc=remove_readonly)
+
+
+def validate_project_path(project_path):
+    """
+        The function validates the path of the project for export 
+    """
+    
+    # checks if the path exists 
+    if not os.path.exists(project_path):
+        raise FileNotFoundError(f"Path does not exist: {project_path}")
+
+    # checks if the path is not a dir
+    if not os.path.isdir(project_path):
+        raise NotADirectoryError(f"Path is not a directory: {project_path}")
+
+    return project_path

bundle_deps-0.1.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: bundle-deps
+Version: 0.1.0
+Summary: Bundle a project's npm and uv dependencies for offline use
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: tqdm
+
+# bundle-deps
+
+Bundle a project's npm and uv dependencies (from its lock files) for offline use.
+
+## Install
+
+    pip install bundle-deps          # from PyPI
+    pip install git+<repo-url>       # or straight from git
+
+## Usage
+
+    bundle-deps <project_path> [--commit-sha SHA | --latest-commit] [--manylinux]
+                [--no-pack] [--bundle-name NAME] [--output-dir DIR] [-v]
+
+Also runnable as `python -m bundle_deps`.

bundle_deps-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+bundle_deps/__init__.py,sha256=gvRFr-O_EIWOAfJpqfAc-Sn3dfnaGjwMVSy_FqDI90U,29
+bundle_deps/__main__.py,sha256=M7th6FI15cyGCDJ_AEIFmEH7miCoqKV7vgD1PDdEpqA,72
+bundle_deps/archive.py,sha256=OXNc3e4qNNGDOpNF8xTV-Im0jhFU4H8Lm7fNXqkj4h8,1201
+bundle_deps/cli.py,sha256=fc8LswY58tyd0SflZwSxduvnqZfnKMSQ_Oz9cRMA9f4,1580
+bundle_deps/download.py,sha256=pcxvpz1nH1YrT6KdmojWZzRGokKTQMVje9rhjYcOiWo,5811
+bundle_deps/export.py,sha256=5IiOHbdnu0gNP_m49DIRYznr29V3SYiNnm6LVT9yIws,4885
+bundle_deps/git_source.py,sha256=uQuAbbOoMeS3D5qRMYVm2etD7P36KNmz-1QiiQ5FboU,1755
+bundle_deps/locks.py,sha256=RL6EGNpxNVS4hxtBnUNkUMggMelWG4MqemOPJ7T-cfI,4429
+bundle_deps/utils.py,sha256=6_iykYCvzuFCVCUXpGIcCo8bDY7HIdooodeqgo_MMHA,1333
+bundle_deps-0.1.0.dist-info/METADATA,sha256=ae9k3gB8hE6wkeT72Fp7FpJcFnvtYLNjnGzK5Pfj4Kk,660
+bundle_deps-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+bundle_deps-0.1.0.dist-info/entry_points.txt,sha256=6qSTb_2g8OOZcmXjCEB04w2MUDa4y5rgtfLH4BwbXgQ,53
+bundle_deps-0.1.0.dist-info/top_level.txt,sha256=zcmmZuu3jllvWjrTXDJ1JeICXUU-RqfkPZd8um6Gq50,12
+bundle_deps-0.1.0.dist-info/RECORD,,

bundle_deps-0.1.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
+

bundle_deps-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bundle-deps = bundle_deps.cli:main

bundle_deps-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bundle_deps