dev-tools-loader 0.1.0__tar.gz

dev_tools_loader-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 KARMA-Electronics
+
+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.

dev_tools_loader-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: dev_tools_loader
+Version: 0.1.0
+Summary: Development tools loader
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/karma_electronics/desktop/dev_tools_loader
+Project-URL: Repository, https://gitlab.com/karma_electronics/desktop/dev_tools_loader.git
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Development Tools Loader
+
+A CLI tool for automated downloading of development tools:
+
+- VS Code installers and extensions (`.vsix` files).
+- Python installers and pip packages;
+
+The tool ensures version compatibility, handles dependencies, and supports repeatable configurations via JSON.
+
+
+## Key Features
+
+- **Version control**: Ensures VS Code extension versions match the target VS Code engine version.
+- **Package bundles**: Supports downloading multiple packages/extensions in a single config.
+- **Dependency handling**: Automatically resolves and downloads dependencies for VS Code extensions.
+- **Resilient downloads**: Automatically retries on connection loss.
+- **Repeatable setups**: JSON-based configuration enables reproducible environment setups.
+- **Flexible versioning**: Supports `"latest"` for extensions and packages.
+
+
+## Installation
+
+```bash
+pip install dev-tools-loader
+```
+
+
+## Running
+
+Once installed, you can run the tool from the command line using the JSON configuration file.
+
+```bash
+dev_tools_loader -j path/to/config.json
+```
+
+
+## Command‑Line Options
+
+- **`-j`, `--json-path` *`<json_config_path>`*** **(required)** Specifies the path to the JSON configuration file that defines download targets.
+- **`-o`, `--output-path` *`<output_dir>`*** Sets the output directory where downloaded files will be saved.
+- **`-c`, `--clean`** If specified, deletes files in the target output directory before starting the download process.
+- **`-h`, `--help`** Displays the help message with a summary of all available options and exits.
+- **`--version`** Prints the current version of the `dev-tools-loader` package and exits.
+
+
+## Example Config
+
+```json
+{
+    "version": "0.1.0",
+    "targets": [
+        {
+            "type": "python",
+            "platform": "win_amd64",
+            "version": "3.12.0",
+            "installer": "load",
+            "packages": [
+                {
+                    "name": "compiledb",
+                    "version": "0.10.6"
+                },
+                {
+                    "name": "requests",
+                    "version": "latest"
+                }
+            ]
+        },
+        {
+            "type": "vscode",
+            "platform": "win32-x64",
+            "version": "1.96.0",
+            "installer": "load",
+            "extensions": [
+                {
+                    "uid": "ms-vscode.cpptools",
+                    "version": "1.28.0"
+                },
+                {
+                    "uid": "ms-python.python",
+                    "version": "latest"
+                }
+            ]
+        }
+    ]
+}
+```
+
+
+## Configuration Fields
+
+- `version` (str): Schema version.
+- `targets` (list): List of download targets. Each target has:
+  - `type` (str): `"python"` or `"vscode"`.
+  - `platform` (str): Target platform (see supported platforms below).
+  - `version` (str): Version of the tool.
+  - `installer` (str): `"load"` to download installer or `"skip"`.
+  - `packages` (list, Python-only): List of pip packages to download.
+    - `name` (str): Package name.
+    - `version` (str): Package version (`"latest"` supported).
+  - `extensions` (list, VS Code-only): List of VS Code extensions to download.
+    - `uid` (str): Extension ID (e.g., `"ms-vscode.cpptools"`).
+    - `version` (str): Extension version (`"latest"` supported).
+
+
+## Supported Platforms Python
+
+- `win32`
+- `win_amd64`
+- `win_arm64`
+- `manylinux1_x86_64`
+- `manylinux2010_x86_64`
+- `manylinux2014_x86_64`
+- `manylinux1_i686`
+- `manylinux2010_i686`
+- `manylinux2014_i686`
+- `manylinux2014_aarch64`
+- `manylinux2014_armv7l`
+- `macosx_10_9_x86_64`
+- `macosx_11_0_arm64`
+
+## Supported Platforms VS Code
+
+- `win32-x64`
+- `win32-arm64`
+- `linux-x64`
+- `linux-arm64`
+- `linux-armhf`
+- `alpine-x64`
+- `alpine-arm64`
+- `darwin-x64`
+- `darwin-arm64`

dev_tools_loader-0.1.0/README.md

@@ -0,0 +1,131 @@
+# Development Tools Loader
+
+A CLI tool for automated downloading of development tools:
+
+- VS Code installers and extensions (`.vsix` files).
+- Python installers and pip packages;
+
+The tool ensures version compatibility, handles dependencies, and supports repeatable configurations via JSON.
+
+
+## Key Features
+
+- **Version control**: Ensures VS Code extension versions match the target VS Code engine version.
+- **Package bundles**: Supports downloading multiple packages/extensions in a single config.
+- **Dependency handling**: Automatically resolves and downloads dependencies for VS Code extensions.
+- **Resilient downloads**: Automatically retries on connection loss.
+- **Repeatable setups**: JSON-based configuration enables reproducible environment setups.
+- **Flexible versioning**: Supports `"latest"` for extensions and packages.
+
+
+## Installation
+
+```bash
+pip install dev-tools-loader
+```
+
+
+## Running
+
+Once installed, you can run the tool from the command line using the JSON configuration file.
+
+```bash
+dev_tools_loader -j path/to/config.json
+```
+
+
+## Command‑Line Options
+
+- **`-j`, `--json-path` *`<json_config_path>`*** **(required)** Specifies the path to the JSON configuration file that defines download targets.
+- **`-o`, `--output-path` *`<output_dir>`*** Sets the output directory where downloaded files will be saved.
+- **`-c`, `--clean`** If specified, deletes files in the target output directory before starting the download process.
+- **`-h`, `--help`** Displays the help message with a summary of all available options and exits.
+- **`--version`** Prints the current version of the `dev-tools-loader` package and exits.
+
+
+## Example Config
+
+```json
+{
+    "version": "0.1.0",
+    "targets": [
+        {
+            "type": "python",
+            "platform": "win_amd64",
+            "version": "3.12.0",
+            "installer": "load",
+            "packages": [
+                {
+                    "name": "compiledb",
+                    "version": "0.10.6"
+                },
+                {
+                    "name": "requests",
+                    "version": "latest"
+                }
+            ]
+        },
+        {
+            "type": "vscode",
+            "platform": "win32-x64",
+            "version": "1.96.0",
+            "installer": "load",
+            "extensions": [
+                {
+                    "uid": "ms-vscode.cpptools",
+                    "version": "1.28.0"
+                },
+                {
+                    "uid": "ms-python.python",
+                    "version": "latest"
+                }
+            ]
+        }
+    ]
+}
+```
+
+
+## Configuration Fields
+
+- `version` (str): Schema version.
+- `targets` (list): List of download targets. Each target has:
+  - `type` (str): `"python"` or `"vscode"`.
+  - `platform` (str): Target platform (see supported platforms below).
+  - `version` (str): Version of the tool.
+  - `installer` (str): `"load"` to download installer or `"skip"`.
+  - `packages` (list, Python-only): List of pip packages to download.
+    - `name` (str): Package name.
+    - `version` (str): Package version (`"latest"` supported).
+  - `extensions` (list, VS Code-only): List of VS Code extensions to download.
+    - `uid` (str): Extension ID (e.g., `"ms-vscode.cpptools"`).
+    - `version` (str): Extension version (`"latest"` supported).
+
+
+## Supported Platforms Python
+
+- `win32`
+- `win_amd64`
+- `win_arm64`
+- `manylinux1_x86_64`
+- `manylinux2010_x86_64`
+- `manylinux2014_x86_64`
+- `manylinux1_i686`
+- `manylinux2010_i686`
+- `manylinux2014_i686`
+- `manylinux2014_aarch64`
+- `manylinux2014_armv7l`
+- `macosx_10_9_x86_64`
+- `macosx_11_0_arm64`
+
+## Supported Platforms VS Code
+
+- `win32-x64`
+- `win32-arm64`
+- `linux-x64`
+- `linux-arm64`
+- `linux-armhf`
+- `alpine-x64`
+- `alpine-arm64`
+- `darwin-x64`
+- `darwin-arm64`

dev_tools_loader-0.1.0/dev_tools_loader/__init__.py

@@ -0,0 +1,5 @@
+from .dev_tools_loader import DevToolsLoader
+
+__all__ = ['DevToolsLoader']
+
+__version__ = '0.1.0'

dev_tools_loader-0.1.0/dev_tools_loader/__main__.py

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

dev_tools_loader-0.1.0/dev_tools_loader/cli.py

@@ -0,0 +1,31 @@
+import os
+import argparse
+from pathlib import Path
+
+from .dev_tools_loader import DebugLog, DevToolsLoader
+from dev_tools_loader import __version__
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Development tools loader CLI')
+    parser.add_argument('-j', '--json-path', help='Path to JSON config file', action='store', required=True)
+    parser.add_argument('-o', '--output-path', help='Path to output dir (default ./output)', action='store', default=Path(os.getcwd()) / Path('output'))
+    parser.add_argument('-c', '--clean', help='Clean output before load (default False)', action='store_true')
+    parser.add_argument('--version', help='Show version', action='version', version=f'%(prog)s {__version__}')
+    args = parser.parse_args()
+
+    try:
+        dtl = DevToolsLoader(args.json_path, args.output_path, args.clean)
+        dtl.run()
+
+    except KeyboardInterrupt:
+        DebugLog.log(f'\n>>> Exit by user', color='yellow')
+
+    except ValueError as e:
+        DebugLog.log(f'\n>>> Value error: {e}', color='red')
+
+    except RuntimeError as e:
+        DebugLog.log(f'\n>>> Runtime error: {e}', color='red')
+
+    finally:
+        pass

dev_tools_loader-0.1.0/dev_tools_loader/dev_tools_loader.py

@@ -0,0 +1,397 @@
+import os
+import sys
+import re
+import shutil
+import time
+import json
+import runpy
+import urllib.request
+from pathlib import Path
+from typing import Tuple
+
+
+#----------------------------------------------------------------------------------------------------------------------
+
+class DebugLog:
+    __colors = {
+        'black':            '\033[30m',
+        'red':              '\033[31m',
+        'green':            '\033[32m',
+        'yellow':           '\033[33m',
+        'blue':             '\033[34m',
+        'magenta':          '\033[35m',
+        'cyan':             '\033[36m',
+        'white':            '\033[37m',
+        'orange':           '\033[38;5;214m',
+        'bright_black':     '\033[90m',
+        'bright_red':       '\033[91m',
+        'bright_green':     '\033[92m',
+        'bright_yellow':    '\033[93m',
+        'bright_blue':      '\033[94m',
+        'bright_magenta':   '\033[95m',
+        'bright_cyan':      '\033[96m',
+        'bright_white':     '\033[97m',
+        'gray_yellow':      '\033[38;5;186m',
+        'reset': '\033[0m',
+    }
+
+
+    def __supports_color() -> bool:
+        if not sys.stdout.isatty():
+            return False
+        if not sys.platform.startswith('win'):
+            return True
+        term = os.environ.get('TERM', '')
+        if 'xterm' in term or 'ansi' in term or 'cygwin' in term:
+            return True
+        if os.environ.get('ANSICON') or os.environ.get('WT_SESSION') or os.environ.get('TERM_PROGRAM', '') == 'vscode':
+            return True
+        return False
+
+
+    __enable_colors = __supports_color()
+
+
+    @staticmethod
+    def log(msg: str, color=None, end='\n', flush=False) -> None:
+        if color and DebugLog.__enable_colors:
+            print(DebugLog.__colors[color], msg, DebugLog.__colors['reset'], sep='', end=end, flush=flush)
+        else:
+            print(msg, end=end, flush=flush)
+
+
+    @staticmethod
+    def new_line() -> None:
+        print()
+
+
+    @staticmethod
+    def sep_by_sides(left_side: str, right_side: str = '', color=None, end='\n', flush=False) -> None:
+        width = shutil.get_terminal_size().columns
+        space = width - len(left_side) - len(right_side) - 1
+        if space > 0:
+            msg = f'\r{left_side:{len(left_side) + space}}{right_side}'
+        else:
+            short_left_side = left_side[:14] + '...' + left_side[14 + 3 + 2 - space:] + '  '
+            msg = f'\r{short_left_side}{right_side}'
+        DebugLog.log(msg, color=color, end=end, flush=flush)
+
+#----------------------------------------------------------------------------------------------------------------------
+
+class DevToolsLoader:
+    EXPECTED_JSON_VERSION = '0.1.0'
+    LOAD_RETRY_QTY = 5
+
+    PYTHON_PLATFORMS = [
+        'win32',                    # Windows 32-bit
+        'win_amd64',                # Windows 64-bit
+        'win_arm64',                # Windows ARM64
+        'manylinux1_x86_64',        # Linux 64-bit (old)
+        'manylinux2010_x86_64',     # Linux 64-bit
+        'manylinux2014_x86_64',     # Linux 64-bit
+        'manylinux1_i686',          # Linux 32-bit
+        'manylinux2010_i686',       # Linux 32-bit
+        'manylinux2014_i686',       # Linux 32-bit
+        'manylinux2014_aarch64',    # Linux ARM64
+        'manylinux2014_armv7l',     # Linux ARM32
+        'macosx_10_9_x86_64',       # macOS Intel
+        'macosx_11_0_arm64',        # macOS Apple Silicon
+    ]
+
+    VSCODE_PLATFORMS = [
+        'win32-x64',
+        'win32-arm64',
+        'linux-x64',
+        'linux-arm64',
+        'linux-armhf',
+        'alpine-x64',
+        'alpine-arm64',
+        'darwin-x64',
+        'darwin-arm64',
+    ]
+
+
+    def __init__(self, json_path: Path, output_path: Path = None, clean: bool = False):
+        if json_path:
+            json_path = Path(json_path)
+            if json_path.exists():
+                with open(json_path, 'r', encoding='utf-8') as f:
+                    raw_json = f.read()
+                    raw_json = re.sub(r'.*//.*', '', raw_json)
+                    raw_json = re.sub(r'/\*[\s\S]*?\*/', '', raw_json)
+                    self.__config = json.loads(raw_json)
+            else:
+                raise ValueError(f'JSON file \'{json_path}\' doesn\'t exist')
+
+            if self.__config['version'] != DevToolsLoader.EXPECTED_JSON_VERSION:
+                raise ValueError(f'incompatible JSON version - \'{self.__config["version"]}\', expected - \'{DevToolsLoader.EXPECTED_JSON_VERSION}\'')
+        else:
+            raise ValueError(f'json path required parameter')
+
+        if output_path:
+            self.__output_path = Path(output_path)
+        else:
+            self.__output_path = Path(os.getcwd()) / Path('output')
+        self.__clean = clean
+
+
+    @staticmethod
+    def __ver_2_tuple(ver_mmpb: str) -> Tuple[int]:
+        ver_mmp = ver_mmpb.split('-')[0]
+        return tuple(int(x) for x in ver_mmp.split('.'))
+
+
+    @staticmethod
+    def __load_file(url: str, dest_path: Path, deep: int = 0) -> None:
+        dest_path = Path(dest_path)
+        temp_path = Path(str(dest_path) + '.part')
+        tree_str = ''
+        if deep > 0:
+            tree_str = '└' + (deep * '────')[1:-1] + ' '
+        left_side = f'{tree_str}{dest_path}'
+
+        if dest_path.exists():
+            DebugLog.sep_by_sides(left_side, 'EXISTS', color='bright_black', end='', flush=True)
+        else:
+            DebugLog.sep_by_sides(left_side, color='gray_yellow', end='', flush=True)
+            start_time = time.time()
+            for attempt in range(DevToolsLoader.LOAD_RETRY_QTY):
+                try:
+                    with urllib.request.urlopen(url) as response, open(temp_path, 'wb') as out_file:
+                        total_size = int(response.headers['Content-Length'], 0)
+                        block_size = 128 * 1024
+                        download_size = 0
+                        while download_size < total_size:
+                            chunk = response.read(block_size)
+                            out_file.write(chunk)
+                            download_size += len(chunk)
+                            percent = download_size * 100 // total_size
+                            minutes, seconds = divmod(int(time.time() - start_time), 60)
+                            left_side = f'{tree_str}{dest_path}'
+                            right_side = f'{percent}% {download_size // 1024:8}KB   {minutes:02d}:{seconds:02d}'
+                            DebugLog.sep_by_sides(left_side, right_side, color='gray_yellow' if percent < 100 else 'bright_green', end='', flush=True)
+                    temp_path.rename(dest_path)
+                    break
+                except (ConnectionResetError, urllib.error.URLError):
+                    DebugLog.sep_by_sides(left_side, 'FAILED', color='red')
+                    time.sleep(2)
+            else:
+                raise RuntimeError(f'failed to load \'{url}\'')
+
+        DebugLog.new_line()
+
+
+    def __load_python(self, cfg: dict):
+        # make dir
+        target_path = self.__output_path / Path(f'python-{cfg["platform"]}-{cfg["version"]}')
+        if self.__clean:
+            DebugLog.log(f'>>> Cleaning output \'{target_path}\'', color='bright_cyan')
+            shutil.rmtree(target_path, ignore_errors=True)
+        if not target_path.exists():
+            target_path.mkdir(parents=True, exist_ok=True)
+            DebugLog.log(f'>>> Create dir \'{target_path}\'', color='bright_cyan')
+
+        # load installer
+        if cfg['installer'] == 'load':
+            try:
+                plat, arch = cfg['platform'].split('_')
+                arch = '-' + arch
+            except ValueError:
+                plat = cfg['platform']
+                arch = ''
+            if plat.startswith('win'):
+                ver = cfg['version']
+                file_name = f'python-{ver}{arch}.exe'
+                dest = target_path / Path(file_name)
+                url = f'https://www.python.org/ftp/python/{ver}/{file_name}'
+                DebugLog.log(f'>>> Loading python {ver} for platform {cfg["platform"]}', color='bright_cyan')
+                DevToolsLoader.__load_file(url, dest)
+            else:
+                DebugLog.log(f'>>> Load python for Linux is not supported yet', color='red')
+                # ver_major = ver.split('.')[0] + '.' + ver.split('.')[1]
+                # file_name = f'python{ver_major}_{ver}_{arch}.deb'
+                # dest = VSCODE_PATH / Path(file_name)
+                # url = f'https://deb.debian.org/debian/pool/main/p/python{ver_major}/{file_name}'
+
+        # load packages
+        if cfg.get('packages'):
+            for pkg in cfg['packages']:
+                pkg_name = pkg['name']
+                if pkg['version'] != 'latest':
+                    pkg_name +=  f'=={pkg["version"]}'
+
+                pip_args = [
+                    'pip', 'download', pkg_name,
+                    '--only-binary=:all:', '-q', '--disable-pip-version-check',
+                    '--python-version', cfg['version'],
+                    '--platform', cfg['platform'],
+                    '-d', str(target_path)
+                ]
+
+                DebugLog.log(f'>>> Loading python package \'{pkg_name}\'', color='bright_cyan')
+                old_argv = sys.argv
+                sys.argv = pip_args
+
+                try:
+                    runpy.run_module('pip', run_name='__main__')
+                    sys.argv
+                except SystemExit as e:
+                    if e.code != 0:
+                        raise RuntimeWarning(f'failed to install {pkg_name} for platform {cfg["platform"]}')
+                finally:
+                    sys.argv = old_argv
+
+        #save setup script
+        setup = ''
+        setup_path = target_path / Path('setup' + ('.bat' if cfg["platform"].startswith('win') else '.sh'))
+        for root, dirs, files in os.walk(target_path):
+            for file in files:
+                if Path(file).suffix == '.whl':
+                    setup += f'pip install --no-index --find-links=./ {file}\n'
+        DebugLog.log(f'>>> Save Python setup script to \'{setup_path}\'', color='bright_cyan')
+        with open(setup_path, 'w', encoding='utf-8') as f:
+            f.write(setup)
+
+
+    @staticmethod
+    def __get_extension_info(uid: str, version: str, engine: str, platform: str) -> dict:
+        api_url = 'https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery'
+
+        query = {
+            'filters': [{ 'criteria': [{'filterType': 7, 'value': f'{uid}'}] }],
+            'flags': 0x1 | 0x2 | 0x10 | 0x80
+        }
+
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json;api-version=3.0-preview.1',
+            'User-Agent': 'Offline VSIX/1.0'
+        }
+
+        data = json.dumps(query).encode('utf-8')
+        req = urllib.request.Request(api_url, data, headers)
+
+        for attempt in range(DevToolsLoader.LOAD_RETRY_QTY):
+            try:
+                with urllib.request.urlopen(req) as resp:
+                    info_list: list[dict] = json.load(resp)['results'][0]['extensions'][0]['versions']
+                    # response_path = DevToolsLoader.TEMP_PATH / Path('response')
+                    # if not response_path.exists():
+                    #     response_path.mkdir(parents=True, exist_ok=True)
+                    # with open(response_path / Path(f'{uid}.json'), 'w', encoding='utf-8') as f:
+                    #     json.dump(info_list, f, indent=4)
+                    #     f.write('\n')
+
+                    for info in info_list:
+                        if info.get('targetPlatform') and platform is None:
+                            raise RuntimeError(f'platform must be specified for {uid} platform')
+
+                        if info.get('targetPlatform') is None or info['targetPlatform'] == platform:
+                            for prop in info['properties']:
+                                if prop['key'] == 'Microsoft.VisualStudio.Code.Engine':
+                                    ext_engine = prop['value'].replace('^', '')
+                                    break
+                            else:
+                                raise RuntimeError('failed to find Microsoft.VisualStudio.Code.Engine')
+
+                            if engine == 'latest' or DevToolsLoader.__ver_2_tuple(ext_engine) <= DevToolsLoader.__ver_2_tuple(engine):
+                                if version == 'latest' or version == info['version']:
+                                    return info
+                    else:
+                        raise RuntimeError(f'failed to find \'{uid}\' info')
+            except (ConnectionResetError, urllib.error.URLError):
+                time.sleep(2)
+        else:
+            raise RuntimeError(f'failed to connect \'{api_url}\'')
+
+
+    @staticmethod
+    def __load_vscode_extension_recursive(target_path: Path, uid: str, version: str, engine: str, platform: str, deep: int = 0, seen = None) -> None:
+        if seen is None:
+            seen = set()
+
+        if uid in seen:
+            return
+
+        seen.add(uid)
+
+        info = DevToolsLoader.__get_extension_info(uid, version, engine, platform)
+        for prop in info['files']:
+            if prop['assetType'] == 'Microsoft.VisualStudio.Services.VSIXPackage':
+                url = prop['source']
+                break
+        else:
+            raise RuntimeError(f'failed to find url')
+
+        #url = f'https://{uid.split('.')[0]}.gallery.vsassets.io/_apis/public/gallery/publisher/{uid.split('.')[0]}/extension/{uid.split('.')[1]}/{ver}/assetbyname/Microsoft.VisualStudio.Services.VSIXPackage'
+        #url = f'https://marketplace.visualstudio.com/_apis/public/gallery/publishers/{publisher}/vsextensions/{name}/{ver}/vspackage'
+
+        ver = info['version']
+        plat = info.get('targetPlatform')
+        plat = f'-{plat}' if plat else ''
+        file_name = f'{uid}-{ver}{plat}.vsix'
+        dest = target_path / Path(file_name)
+
+        DevToolsLoader.__load_file(url, dest, deep)
+
+        for prop in info['properties']:
+            if prop['key'] == 'Microsoft.VisualStudio.Code.ExtensionDependencies' or prop['key'] == 'Microsoft.VisualStudio.Code.ExtensionPack':
+                for dep_uid in prop['value'].split(','):
+                    if dep_uid != '':
+                        DevToolsLoader.__load_vscode_extension_recursive(target_path, dep_uid, 'latest', engine, platform, deep + 1, seen)
+
+
+    def __load_vscode(self, cfg: dict) -> None:
+        # make dir
+        target_path = self.__output_path / Path(f'vscode-{cfg["platform"]}-{cfg["version"]}')
+        if self.__clean:
+            DebugLog.log(f'>>> Cleaning output \'{target_path}\'', color='bright_cyan')
+            shutil.rmtree(target_path, ignore_errors=True)
+        if not target_path.exists():
+            target_path.mkdir(parents=True, exist_ok=True)
+            DebugLog.log(f'>>> Create dir \'{target_path}\'', color='bright_cyan')
+
+        # load installer
+        if cfg['installer'] == 'load':
+            plat = cfg['platform']
+            engine = cfg['version']
+            if plat.startswith('win'):
+                suffix = '.exe'
+            elif plat.startswith('darwin'):
+                suffix = '.zip'
+            elif plat.startswith('linux'):
+                suffix = '.tar.gz'
+            else:
+                suffix = None
+                DebugLog.log(f'>>> Load vscode for {plat} is not supported yet', color='red')
+            if suffix:
+                url_plat = plat if plat != 'darwin-x64' else 'darwin'
+                url = f'https://update.code.visualstudio.com/{engine}/{url_plat}/stable'
+                dest = target_path / Path(f'vscode-{engine}-{plat}{suffix}')
+                DebugLog.log(f'>>> Loading vscode {engine} for platform {plat}', color='bright_cyan')
+                DevToolsLoader.__load_file(url, dest)
+
+        # load extensions
+        if cfg.get('extensions'):
+            for ext in cfg['extensions']:
+                DevToolsLoader.__load_vscode_extension_recursive(target_path, ext['uid'], ext['version'], cfg['version'], cfg['platform'])
+
+        setup = ''
+        setup_path = target_path / Path('setup' + ('.bat' if cfg["platform"].startswith('win') else '.sh'))
+        for root, dirs, files in os.walk(target_path):
+            for file in files:
+                if Path(file).suffix == '.vsix':
+                    setup += f'code --force --install-extension {file}\n'
+        DebugLog.log(f'>>> Save VSCode setup script to \'{setup_path}\'', color='bright_cyan')
+        with open(setup_path, 'w', encoding='utf-8') as f:
+            f.write(setup)
+
+
+    def run(self) -> None:
+        for cfg in self.__config['targets']:
+            if cfg['type'] == 'python':
+                self.__load_python(cfg)
+            elif cfg['type'] == 'vscode':
+                self.__load_vscode(cfg)
+            else:
+                raise ValueError(f'invalid target type \'{cfg["type"]}\'')

dev_tools_loader-0.1.0/dev_tools_loader.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: dev_tools_loader
+Version: 0.1.0
+Summary: Development tools loader
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/karma_electronics/desktop/dev_tools_loader
+Project-URL: Repository, https://gitlab.com/karma_electronics/desktop/dev_tools_loader.git
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Development Tools Loader
+
+A CLI tool for automated downloading of development tools:
+
+- VS Code installers and extensions (`.vsix` files).
+- Python installers and pip packages;
+
+The tool ensures version compatibility, handles dependencies, and supports repeatable configurations via JSON.
+
+
+## Key Features
+
+- **Version control**: Ensures VS Code extension versions match the target VS Code engine version.
+- **Package bundles**: Supports downloading multiple packages/extensions in a single config.
+- **Dependency handling**: Automatically resolves and downloads dependencies for VS Code extensions.
+- **Resilient downloads**: Automatically retries on connection loss.
+- **Repeatable setups**: JSON-based configuration enables reproducible environment setups.
+- **Flexible versioning**: Supports `"latest"` for extensions and packages.
+
+
+## Installation
+
+```bash
+pip install dev-tools-loader
+```
+
+
+## Running
+
+Once installed, you can run the tool from the command line using the JSON configuration file.
+
+```bash
+dev_tools_loader -j path/to/config.json
+```
+
+
+## Command‑Line Options
+
+- **`-j`, `--json-path` *`<json_config_path>`*** **(required)** Specifies the path to the JSON configuration file that defines download targets.
+- **`-o`, `--output-path` *`<output_dir>`*** Sets the output directory where downloaded files will be saved.
+- **`-c`, `--clean`** If specified, deletes files in the target output directory before starting the download process.
+- **`-h`, `--help`** Displays the help message with a summary of all available options and exits.
+- **`--version`** Prints the current version of the `dev-tools-loader` package and exits.
+
+
+## Example Config
+
+```json
+{
+    "version": "0.1.0",
+    "targets": [
+        {
+            "type": "python",
+            "platform": "win_amd64",
+            "version": "3.12.0",
+            "installer": "load",
+            "packages": [
+                {
+                    "name": "compiledb",
+                    "version": "0.10.6"
+                },
+                {
+                    "name": "requests",
+                    "version": "latest"
+                }
+            ]
+        },
+        {
+            "type": "vscode",
+            "platform": "win32-x64",
+            "version": "1.96.0",
+            "installer": "load",
+            "extensions": [
+                {
+                    "uid": "ms-vscode.cpptools",
+                    "version": "1.28.0"
+                },
+                {
+                    "uid": "ms-python.python",
+                    "version": "latest"
+                }
+            ]
+        }
+    ]
+}
+```
+
+
+## Configuration Fields
+
+- `version` (str): Schema version.
+- `targets` (list): List of download targets. Each target has:
+  - `type` (str): `"python"` or `"vscode"`.
+  - `platform` (str): Target platform (see supported platforms below).
+  - `version` (str): Version of the tool.
+  - `installer` (str): `"load"` to download installer or `"skip"`.
+  - `packages` (list, Python-only): List of pip packages to download.
+    - `name` (str): Package name.
+    - `version` (str): Package version (`"latest"` supported).
+  - `extensions` (list, VS Code-only): List of VS Code extensions to download.
+    - `uid` (str): Extension ID (e.g., `"ms-vscode.cpptools"`).
+    - `version` (str): Extension version (`"latest"` supported).
+
+
+## Supported Platforms Python
+
+- `win32`
+- `win_amd64`
+- `win_arm64`
+- `manylinux1_x86_64`
+- `manylinux2010_x86_64`
+- `manylinux2014_x86_64`
+- `manylinux1_i686`
+- `manylinux2010_i686`
+- `manylinux2014_i686`
+- `manylinux2014_aarch64`
+- `manylinux2014_armv7l`
+- `macosx_10_9_x86_64`
+- `macosx_11_0_arm64`
+
+## Supported Platforms VS Code
+
+- `win32-x64`
+- `win32-arm64`
+- `linux-x64`
+- `linux-arm64`
+- `linux-armhf`
+- `alpine-x64`
+- `alpine-arm64`
+- `darwin-x64`
+- `darwin-arm64`

dev_tools_loader-0.1.0/dev_tools_loader.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+dev_tools_loader/__init__.py
+dev_tools_loader/__main__.py
+dev_tools_loader/cli.py
+dev_tools_loader/dev_tools_loader.py
+dev_tools_loader.egg-info/PKG-INFO
+dev_tools_loader.egg-info/SOURCES.txt
+dev_tools_loader.egg-info/dependency_links.txt
+dev_tools_loader.egg-info/entry_points.txt
+dev_tools_loader.egg-info/top_level.txt
+tests/test_dev_tools_loader.py

dev_tools_loader-0.1.0/dev_tools_loader.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dev_tools_loader-0.1.0/dev_tools_loader.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dev_tools_loader = dev_tools_loader.cli:main

dev_tools_loader-0.1.0/dev_tools_loader.egg-info/top_level.txt

@@ -0,0 +1 @@
+dev_tools_loader

dev_tools_loader-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dev_tools_loader"
+version = "0.1.0"
+description = "Development tools loader"
+readme = "README.md"
+requires-python = ">=3.6"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = []
+
+[project.scripts]
+dev_tools_loader = "dev_tools_loader.cli:main"
+
+[tool.setuptools]
+packages = ["dev_tools_loader"]
+
+[project.urls]
+Homepage = "https://gitlab.com/karma_electronics/desktop/dev_tools_loader"
+Repository = "https://gitlab.com/karma_electronics/desktop/dev_tools_loader.git"

dev_tools_loader-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dev_tools_loader-0.1.0/tests/test_dev_tools_loader.py

@@ -0,0 +1,127 @@
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import patch
+
+from dev_tools_loader.dev_tools_loader import DevToolsLoader
+from dev_tools_loader.cli import main
+
+
+@pytest.fixture
+def config_template():
+    return {
+        'version': '0.1.0',
+        'targets': [
+            {
+                'type': 'python',
+                'platform': 'none',
+                'version': '3.12.0',
+                'installer': "load",
+                'packages': [
+                    {
+                        'name': 'compiledb',
+                        'version': '0.10.6'
+                    },
+                    {
+                        'name': 'pyserial',
+                        'version': '3.2'
+                    },
+                    {
+                        'name': 'requests',
+                        'version': 'latest'
+                    }
+                ]
+            },
+            {
+                'type': 'vscode',
+                'platform': 'none',
+                'version': '1.96.0',
+                'installer': "load",
+                'extensions': [
+                    {
+                        'uid': 'ms-vscode.cpptools',
+                        'version': '1.28.0'
+                    },
+                    {
+                        'uid': 'ms-python.python',
+                        'version': 'latest'
+                    },
+                    {
+                        'uid': 'ms-python.debugpy',
+                        'version': 'latest'
+                    },
+                    {
+                        'uid': 'marus25.cortex-debug',
+                        'version': '1.12.0'
+                    },
+                    {
+                        'uid': 'streetsidesoftware.code-spell-checker-russian',
+                        'version': 'latest'
+                    }
+                ]
+            }
+        ]
+    }
+
+
+def save_json_config(json_path: Path, config: dict) -> None:
+    json_path = Path(json_path)
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(config, f, indent=4)
+        f.write('\n')
+
+
+@pytest.mark.fast
+def test_cli_help():
+    print()
+    with patch('sys.argv', ['dev_tools_loader', '-h']):
+        with pytest.raises(SystemExit):
+            main()
+
+
+@pytest.mark.fast
+def test_cli_version():
+    print()
+    with patch('sys.argv', ['dev_tools_loader', '--version']):
+        with pytest.raises(SystemExit):
+            main()
+
+
+@pytest.mark.fast
+def test_cli_invalid_config():
+    print()
+    with patch('sys.argv', ['dev_tools_loader']):
+        with pytest.raises(SystemExit):
+            main()
+
+
+@pytest.mark.fast
+def test_config_example(tmp_path):
+    print()
+    config_path = Path(__file__).parent / Path('data/config_example.json')
+    with patch('sys.argv', ['dev_tools_loader', '-j', str(config_path), '-o', str(tmp_path)]):
+        main()
+
+
+@pytest.mark.parametrize('platform', DevToolsLoader.PYTHON_PLATFORMS)
+def test_python_load(config_template, platform, tmp_path):
+    config = config_template
+    config['targets'][0]['platform'] = platform
+    config['targets'].pop(1)
+    json_path = tmp_path / Path(f'config_python_{platform}.json')
+    save_json_config(json_path, config)
+    print()
+    dtl = DevToolsLoader(json_path, tmp_path)
+    dtl.run()
+
+
+@pytest.mark.parametrize('platform', DevToolsLoader.VSCODE_PLATFORMS)
+def test_vscode_load(config_template, platform, tmp_path):
+    config = config_template
+    config['targets'][1]['platform'] = platform
+    config['targets'].pop(0)
+    json_path = tmp_path / Path(f'config_vscode_{platform}.json')
+    save_json_config(json_path, config)
+    print()
+    dtl = DevToolsLoader(json_path, tmp_path)
+    dtl.run()