dotslash 0.5.8__tar.gz

dotslash-0.5.8/.gemini/config.yaml

@@ -0,0 +1,6 @@
+# https://developers.google.com/gemini-code-assist/docs/customize-gemini-behavior-github
+have_fun: false
+code_review:
+  pull_request_opened:
+    summary: false
+    code_review: false

dotslash-0.5.8/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

dotslash-0.5.8/.github/workflows/build.yml

@@ -0,0 +1,112 @@
+name: build
+
+on:
+  push:
+    tags:
+    - v*
+    branches:
+    - main
+  pull_request:
+    branches:
+    - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+
+    outputs:
+      dotslash-version: ${{ steps.dotslash-version.outputs.dotslash-version }}
+
+    steps:
+    - uses: actions/checkout@v5
+
+    - name: Set DotSlash version
+      id: dotslash-version
+      run: |-
+        dotslash_version=$(gh api repos/facebook/dotslash/releases/latest --jq '.tag_name')
+        echo "dotslash-version=${dotslash_version}" >> $GITHUB_OUTPUT
+      env:
+        GH_TOKEN: ${{ github.token }}
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v6
+
+    - name: Build source distribution
+      run: uv build --sdist
+      env:
+        DOTSLASH_VERSION: ${{ steps.dotslash-version.outputs.dotslash-version }}
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: artifact-sdist
+        path: dist/*
+        if-no-files-found: error
+
+  wheels:
+    name: Build wheels on ${{ matrix.os }}
+    needs:
+    - sdist
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - os: ubuntu-24.04-arm
+          archs: aarch64
+        - os: ubuntu-latest
+          archs: x86_64
+        - os: macos-latest
+          archs: arm64
+        - os: macos-15-intel
+          archs: x86_64
+        - os: windows-11-arm
+          archs: ARM64
+        - os: windows-latest
+          archs: AMD64
+
+    steps:
+    - uses: actions/checkout@v5
+
+    - name: Build wheels
+      uses: pypa/cibuildwheel@v3.2.1
+      env:
+        DOTSLASH_VERSION: ${{ needs.sdist.outputs.dotslash-version }}
+        CIBW_ARCHS: ${{ matrix.archs }}
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: artifact-wheels-${{ matrix.os }}-${{ matrix.archs }}
+        path: wheelhouse/*.whl
+        if-no-files-found: error
+
+  publish:
+    name: Publish release
+    needs:
+    - sdist
+    - wheels
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags')
+
+    permissions:
+      id-token: write
+
+    steps:
+    - uses: actions/download-artifact@v4
+      with:
+        pattern: artifact-*
+        merge-multiple: true
+        path: dist
+
+    - name: Push build artifacts to PyPI
+      uses: pypa/gh-action-pypi-publish@v1.13.0
+      with:
+        skip-existing: true

dotslash-0.5.8/.github/workflows/test.yml

@@ -0,0 +1,34 @@
+name: test
+
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+    branches:
+    - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v5
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v6
+
+    - name: Static analysis
+      run: uvx ruff check ./src
+
+    - name: Formatting
+      run: uvx ruff format --check --diff ./src

dotslash-0.5.8/.gitignore

@@ -0,0 +1,2 @@
+*.pyc
+/dist

dotslash-0.5.8/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: dotslash
+Version: 0.5.8
+Summary: Command-line tool to facilitate fetching an executable, caching it, and then running it.
+Project-URL: Homepage, https://dotslash-cli.com
+Project-URL: Tracker, https://github.com/facebook/dotslash/issues
+Project-URL: Source, https://github.com/facebook/dotslash
+Author-email: Ofek Lev <oss@ofek.dev>
+License-Expression: MIT OR Apache-2.0
+Keywords: dotslash
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# DotSlash: simplified executable deployment
+
+[![CI - Build](https://github.com/ofek/dotslash/actions/workflows/build.yml/badge.svg)](https://github.com/ofek/dotslash/actions/workflows/build.yml)
+[![CI - Test](https://github.com/ofek/dotslash/actions/workflows/test.yml/badge.svg)](https://github.com/ofek/dotslash/actions/workflows/test.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/dotslash.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/dotslash/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/dotslash.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold)](https://pypi.org/project/dotslash/)
+[![Built by Hatch](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
+[![Ruff linting/formatting](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+-----
+
+[DotSlash](https://dotslash-cli.com/docs/) (`dotslash`) is a command-line tool that lets you represent a set of platform-specific, heavyweight executables with an equivalent small, easy-to-read text file. In turn, this makes it efficient to store executables in source control without hurting repository size. This paves the way for checking build toolchains and other tools directly into the repo, reducing dependencies on the host environment and thereby facilitating reproducible builds.
+
+The `dotslash` package allows you to use DotSlash in your Python projects without having to install DotSlash globally.
+
+***Table of Contents***
+
+- [Using as a library](#using-as-a-library)
+- [Using as a command-line tool](#using-as-a-command-line-tool)
+- [License](#license)
+
+## Using as a library
+
+The `dotslash.locate` function returns the path to the DotSlash binary that was installed by this package.
+
+```pycon
+>>> import dotslash
+>>> dotslash.locate()
+'/root/.local/bin/dotslash'
+```
+
+## Using as a command-line tool
+
+The installed DotSlash binary can be invoked directly by running the `dotslash` module as a script.
+
+```
+python -m dotslash path/to/dotslash-file.json
+```
+
+## License
+
+DotSlash is licensed under both the MIT license and Apache-2.0 license; the exact terms can be found in the [LICENSE-MIT]() and LICENSE-APACHE files, respectively.

dotslash-0.5.8/README.md

@@ -0,0 +1,59 @@
+# DotSlash: simplified executable deployment
+
+[![CI - Build](https://github.com/ofek/dotslash/actions/workflows/build.yml/badge.svg)](https://github.com/ofek/dotslash/actions/workflows/build.yml)
+[![CI - Test](https://github.com/ofek/dotslash/actions/workflows/test.yml/badge.svg)](https://github.com/ofek/dotslash/actions/workflows/test.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/dotslash.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/dotslash/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/dotslash.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold)](https://pypi.org/project/dotslash/)
+[![Built by Hatch](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
+[![Ruff linting/formatting](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+-----
+
+[DotSlash](https://dotslash-cli.com/docs/) (`dotslash`) is a command-line tool that lets you represent a set of platform-specific, heavyweight executables with an equivalent small, easy-to-read text file. In turn, this makes it efficient to store executables in source control without hurting repository size. This paves the way for checking build toolchains and other tools directly into the repo, reducing dependencies on the host environment and thereby facilitating reproducible builds.
+
+The `dotslash` package allows you to use DotSlash in your Python projects without having to install DotSlash globally.
+
+***Table of Contents***
+
+- [Using as a library](#using-as-a-library)
+- [Using as a command-line tool](#using-as-a-command-line-tool)
+- [Building from source](#building-from-source)
+- [License](#license)
+
+## Using as a library
+
+The `dotslash.locate` function returns the path to the DotSlash binary that was installed by this package.
+
+```pycon
+>>> import dotslash
+>>> dotslash.locate()
+'/root/.local/bin/dotslash'
+```
+
+## Using as a command-line tool
+
+The installed DotSlash binary can be invoked directly by running the `dotslash` module as a script.
+
+```
+python -m dotslash path/to/dotslash-file.json
+```
+
+## Building from source
+
+When building or installing from this directory, the `DOTSLASH_VERSION` environment variable must be set to the version of DotSlash to use. A preceding `v` is accepted but not required.
+
+```
+DOTSLASH_VERSION=0.5.8 python -m build
+```
+
+This will use the binaries from DotSlash's [GitHub releases](https://github.com/facebook/dotslash/releases). If there is a directory of GitHub release assets, you can use that directly with the `DOTSLASH_SOURCE` environment variable.
+
+```
+DOTSLASH_VERSION=0.5.8 DOTSLASH_SOURCE=path/to/dotslash-assets python -m build
+```
+
+The DotSlash source is set to `release` by default.
+
+## License
+
+DotSlash is licensed under both the MIT license and Apache-2.0 license; the exact terms can be found in the [LICENSE-MIT]() and LICENSE-APACHE files, respectively.

dotslash-0.5.8/hatch_build.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import contextmanager
+from functools import cached_property
+from platform import machine
+from typing import TYPE_CHECKING, Any, BinaryIO
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+
+class CustomBuildHook(BuildHookInterface):
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:  # noqa: ARG002
+        if self.__source == "release":
+            asset = self.__release_asset
+        elif os.path.isdir(self.__source):
+            asset = self.__local_asset
+        elif not os.path.isabs(self.__source) and os.path.isfile(os.path.join(self.root, "PKG-INFO")):
+            msg = (
+                "The current directory has a `PKG-INFO` file, which likely means that the wheel is being "
+                "built from an unpacked source distribution. You must do one of the following:\n"
+                "- Set the source to an absolute rather than relative path.\n"
+                "- Build the wheel separately e.g. run `python -m build --wheel` rather than just `python -m build`.\n"
+                "- Set the source to `release`."
+            )
+            raise ValueError(msg)
+        else:
+            msg = "Source must be `release` or an absolute path to a directory containing release assets"
+            raise ValueError(msg)
+
+        import tarfile
+
+        with asset() as reader, tarfile.open(fileobj=reader, mode="r:gz") as tf:
+            tf.extractall(self.__temp_dir)
+
+        if not os.path.isfile(self.__binary_path):
+            msg = f"Binary not found: {self.__binary_path}"
+            raise RuntimeError(msg)
+
+        build_data["shared_scripts"][self.__binary_path] = self.__binary_name
+        build_data["tag"] = f"py3-none-{self.__wheel_arch}"
+
+    def finalize(self, version: str, build_data: dict[str, Any], artifact: str) -> None:  # noqa: ARG002
+        import shutil
+
+        shutil.rmtree(self.__temp_dir)
+
+    @contextmanager
+    def __release_asset(self) -> Generator[BinaryIO, None, None]:
+        from urllib.request import HTTPError, urlopen
+
+        tag = f"v{self.metadata.version.removeprefix('v')}"
+        url = f"https://github.com/facebook/dotslash/releases/download/{tag}/{self.__asset_name}"
+
+        try:
+            with urlopen(url) as response:
+                yield response
+        except HTTPError as e:
+            e.msg += f"\nURL: {url}"
+            raise
+
+    @contextmanager
+    def __local_asset(self) -> Generator[BinaryIO, None, None]:
+        asset_path = os.path.join(self.__source, self.__asset_name)
+        if not os.path.isfile(asset_path):
+            msg = f"Asset not found: {asset_path}"
+            raise RuntimeError(msg)
+
+        with open(asset_path, "rb") as f:
+            yield f
+
+    @cached_property
+    def __platform(self) -> str:
+        match sys.platform:
+            case "win32":
+                return "windows"
+            case "darwin":
+                return "macos"
+            case "linux":
+                return "linux"
+            case _:
+                msg = f"Unsupported platform: {sys.platform}"
+                raise ValueError(msg)
+
+    @cached_property
+    def __arch(self) -> str:
+        return machine().lower()
+
+    @cached_property
+    def __target_data(self) -> tuple[str, str]:
+        match self.__platform, self.__arch:
+            case "linux", "aarch64":
+                return "dotslash-linux-musl.aarch64.tar.gz", self.__get_linux_wheel_arch()
+            case "linux", "x86_64":
+                return "dotslash-linux-musl.x86_64.tar.gz", self.__get_linux_wheel_arch()
+            case "windows", "arm64":
+                return "dotslash-windows-arm64.tar.gz", "win_arm64"
+            case "windows", "amd64":
+                return "dotslash-windows.tar.gz", "win_amd64"
+            case "macos", "arm64":
+                return "dotslash-macos-arm64.tar.gz", "macosx_11_0_arm64"
+            case "macos", "x86_64":
+                return "dotslash-macos-x86_64.tar.gz", "macosx_10_12_x86_64"
+            case _:
+                msg = f"Unsupported platform/arch pair: {self.__platform} {self.__arch}"
+                raise ValueError(msg)
+
+    @cached_property
+    def __asset_name(self) -> str:
+        return self.__target_data[0]
+
+    @cached_property
+    def __wheel_arch(self) -> str:
+        return self.__target_data[1]
+
+    @cached_property
+    def __source(self) -> str:
+        return os.environ.get("DOTSLASH_SOURCE") or self.config.get("source") or "release"
+
+    @cached_property
+    def __temp_dir(self) -> str:
+        import tempfile
+
+        return tempfile.mkdtemp()
+
+    @cached_property
+    def __binary_name(self) -> str:
+        return "dotslash.exe" if self.__platform == "windows" else "dotslash"
+
+    @cached_property
+    def __binary_path(self) -> str:
+        return os.path.join(self.__temp_dir, self.__binary_name)
+
+    def __get_linux_wheel_arch(self) -> str:
+        default_arch = f"musllinux_1_1_{self.__arch}"
+
+        if not (hasattr(os, "confstr") and "CS_GNU_LIBC_VERSION" in os.confstr_names):
+            return default_arch
+
+        try:
+            value = os.confstr("CS_GNU_LIBC_VERSION")
+        except (OSError, ValueError):
+            pass
+        else:
+            if value and value.startswith("glibc"):
+                return f"manylinux_2_28_{self.__arch}"
+
+        return default_arch

dotslash-0.5.8/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+build-backend = "hatchling.build"
+requires = ["hatchling>=1.27.0", "hatch-fancy-pypi-readme"]
+
+[project]
+name = "dotslash"
+dynamic = ["readme", "version"]
+authors = [
+  { name = "Ofek Lev", email = "oss@ofek.dev" },
+]
+description = "Command-line tool to facilitate fetching an executable, caching it, and then running it."
+keywords = [
+  "dotslash",
+]
+license = "MIT OR Apache-2.0"
+requires-python = ">=3.10"
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Natural Language :: English",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+
+[project.urls]
+Homepage = "https://dotslash-cli.com"
+Tracker = "https://github.com/facebook/dotslash/issues"
+Source = "https://github.com/facebook/dotslash"
+
+[tool.hatch.version]
+source = "env"
+variable = "DOTSLASH_VERSION"
+
+[tool.hatch.metadata.hooks.fancy-pypi-readme]
+content-type = "text/markdown"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+path = "README.md"
+end-before = "## Building from source"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+path = "README.md"
+start-at = "## License"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]]
+pattern = "(?m)^- \\[Building from source.+$\\s+-"
+replacement = "-"
+
+[tool.hatch.build.targets.wheel.hooks.custom]
+
+[tool.cibuildwheel]
+enable = ["pypy"]
+test-command = "python -m dotslash -- cache-dir"
+# Only build on one version of Python since all distributions of a given platform/arch pair are the same
+build = "cp314-*"
+# Disable wheel repair since it's not necessary
+repair-wheel-command = ""
+
+[tool.cibuildwheel.linux]
+environment-pass = ["DOTSLASH_SOURCE", "DOTSLASH_VERSION"]

dotslash-0.5.8/ruff.toml

@@ -0,0 +1,11 @@
+line-length = 120
+
+[format]
+docstring-code-format = true
+docstring-code-line-length = 80
+
+[lint.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[lint.isort]
+known-first-party = ["dotslash"]

dotslash-0.5.8/src/dotslash/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+
+def locate() -> str:
+    """
+    Returns:
+        The path to the DotSlash binary that was installed by this package.
+    """
+    import os
+    import sys
+    import sysconfig
+
+    from dotslash._locate import _search_paths
+
+    if extension := sysconfig.get_config_var("EXE"):
+        binary_name = f"dotslash{extension}"
+    elif sys.platform == "win32":
+        binary_name = "dotslash.exe"
+    else:
+        binary_name = "dotslash"
+
+    # Map of normalized paths to the actual path
+    seen_paths: dict[str, str] = {}
+    for search_path in _search_paths():
+        normalized_path = os.path.normcase(search_path)
+        if normalized_path in seen_paths:
+            continue
+
+        seen_paths[normalized_path] = search_path
+        binary_path = os.path.join(search_path, binary_name)
+        if os.path.isfile(binary_path):
+            return binary_path
+
+    search_paths = "\n".join(f"- {search_path}" for search_path in seen_paths.values())
+    msg = f"The `{binary_name}` binary was not found in any of the following paths:\n{search_paths}"
+    raise FileNotFoundError(msg)

dotslash-0.5.8/src/dotslash/__main__.py

@@ -0,0 +1,16 @@
+if __name__ == "__main__":
+    import sys
+
+    from dotslash import locate
+
+    dotslash = locate()
+
+    if sys.platform == "win32":
+        import subprocess
+
+        process = subprocess.run([dotslash, *sys.argv[1:]])
+        sys.exit(process.returncode)
+    else:
+        import os
+
+        os.execvp(dotslash, [dotslash, *sys.argv[1:]])

dotslash-0.5.8/src/dotslash/_locate.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import os
+import sys
+import sysconfig
+
+
+def _search_paths():
+    # The scripts directory for the current Python installation
+    yield sysconfig.get_path("scripts")
+
+    # The scripts directory for the base prefix if in a virtual environment
+    yield sysconfig.get_path("scripts", vars={"base": sys.base_prefix, "platbase": sys.base_exec_prefix})
+
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    package_parent, package_name = os.path.split(module_dir)
+    if package_name == "dotslash":
+        # Above the package root e.g. when running `pip install --prefix` or `uv run --with`
+        # Windows: <prefix>\Lib\site-packages\dotslash
+        # macOS: <prefix>/lib/pythonX.Y/site-packages/dotslash
+        # Linux:
+        #   <prefix>/lib/pythonX.Y/site-packages/dotslash
+        #   <prefix>/lib/pythonX.Y/dist-packages/dotslash (Debian-based distributions)
+        head, tail = os.path.split(package_parent)
+        if tail.endswith("-packages"):
+            head, tail = os.path.split(head)
+            if sys.platform == "win32":
+                if tail == "Lib":
+                    yield os.path.join(head, "Scripts")
+            elif tail.startswith("python"):
+                head, tail = os.path.split(head)
+                if tail == sys.platlibdir:
+                    yield os.path.join(head, "bin")
+        else:
+            # Adjacent to the package root e.g. when using the `--target` option of pip-like installers
+            yield os.path.join(package_parent, "bin")
+
+    # The scripts directory for user installations
+    yield sysconfig.get_path("scripts", scheme=sysconfig.get_preferred_scheme("user"))