shebang.md•4.11 kB
!!!warning "Only on Unix-like systems"
The following approach only works on Unix-like systems (i.e. Linux and macOS) since Windows does not support shebang lines.
For simple scripts, you can use [`pixi exec`](../reference/cli/pixi/exec.md) to run them directly without needing to take care of installing dependencies or setting up an environment.
This can be done by adding a [shebang line](https://en.wikipedia.org/wiki/Shebang_(Unix)) at the top of the script, which tells the system how to execute the script.
Usually, a shebang line starts with `#!/usr/bin/env` followed by the name of the interpreter to use.
Instead of adding an interpreter, you can also just add `pixi exec` at the beginning of the script.
The only requirement for your script is that you must have `pixi` installed on your system.
!!!tip "Making the script executable"
You might need to make the script executable by running `chmod +x my-script.sh`.
```bash title="use-bat.sh"
#!/usr/bin/env -S pixi exec --spec bat -- bash -e
bat my-file.json
```
!!!info "Explanation what's happening"
The `#!` are magic characters that tell your system how to execute the script (take everything after the `#!` and append the file name).
The `/usr/bin/env` is used to find `pixi` in the system's `PATH`.
The `-S` option tells `/usr/bin/env` to use the first argument as the interpreter and the rest as arguments to the interpreter.
`pixi exec --spec bat` creates a temporary environment containing only [`bat`](https://github.com/sharkdp/bat).
`bash -e` (separated with `--`) is the command that is executed in this environment.
So in total, `pixi exec --spec bat -- bash -e use-bat.sh` is being executed when you run `./use-bat.sh`.
You can also write self-contained python files that ship with their dependencies.
This example shows a very simple CLI that installs a Pixi environment to an arbitrary prefix using [`py-rattler`](https://conda.github.io/rattler/py-rattler) and [`typer`](https://typer.tiangolo.com).
```python title="install-pixi-environment-to-prefix.py"
#!/usr/bin/env -S pixi exec --spec py-rattler>=0.10.0,<0.11 --spec typer>=0.15.0,<0.16 -- python
import asyncio
from pathlib import Path
from typing import get_args
from rattler import install as rattler_install
from rattler import LockFile, Platform
from rattler.platform.platform import PlatformLiteral
from rattler.networking import Client, MirrorMiddleware, AuthenticationMiddleware
import typer
app = typer.Typer()
async def _install(
lock_file_path: Path,
environment_name: str,
platform: Platform,
target_prefix: Path,
) -> None:
lock_file = LockFile.from_path(lock_file_path)
environment = lock_file.environment(environment_name)
if environment is None:
raise ValueError(f"Environment {environment_name} not found in lock file {lock_file_path}")
records = environment.conda_repodata_records_for_platform(platform)
if not records:
raise ValueError(f"No records found for platform {platform} in lock file {lock_file_path}")
await rattler_install(
records=records,
target_prefix=target_prefix,
client=Client(
middlewares=[
MirrorMiddleware({"https://conda.anaconda.org/conda-forge": ["https://repo.prefix.dev/conda-forge"]}),
AuthenticationMiddleware(),
]
),
)
@app.command()
def install(
lock_file_path: Path = Path("pixi.lock").absolute(),
environment_name: str = "default",
platform: str = str(Platform.current()),
target_prefix: Path = Path("env").absolute(),
) -> None:
"""
Installs a pixi.lock file to a custom prefix.
"""
if platform not in get_args(PlatformLiteral):
raise ValueError(f"Invalid platform {platform}. Must be one of {get_args(PlatformLiteral)}")
asyncio.run(
_install(
lock_file_path=lock_file_path,
environment_name=environment_name,
platform=Platform(platform),
target_prefix=target_prefix,
)
)
if __name__ == "__main__":
app()
```