py-rattler 0.22.0__cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

rattler/explicit_environment/__init__.py

@@ -0,0 +1,3 @@
+from rattler.explicit_environment.environment import ExplicitEnvironmentSpec, ExplicitEnvironmentEntry
+
+__all__ = ["ExplicitEnvironmentSpec", "ExplicitEnvironmentEntry"]

rattler/explicit_environment/environment.py

@@ -0,0 +1,69 @@
+from pathlib import Path
+from typing import List, Optional
+
+from rattler.rattler import PyExplicitEnvironmentSpec as _PyExplicitEnvironmentSpec
+from rattler.rattler import PyExplicitEnvironmentEntry as _PyExplicitEnvironmentEntry
+from rattler.platform import Platform
+
+
+class ExplicitEnvironmentEntry:
+    """A wrapper around an explicit environment entry which represents a URL to a package"""
+
+    def __init__(self, inner: _PyExplicitEnvironmentEntry) -> None:
+        self._inner = inner
+
+    @property
+    def url(self) -> str:
+        """Returns the URL of the package"""
+        return self._inner.url()
+
+
+class ExplicitEnvironmentSpec:
+    """The explicit environment (e.g. env.txt) file that contains a list of all URLs in a environment"""
+
+    def __init__(self, inner: _PyExplicitEnvironmentSpec) -> None:
+        self._inner = inner
+
+    @classmethod
+    def from_path(cls, path: Path) -> "ExplicitEnvironmentSpec":
+        """Parses the object from a file specified by a `path`, using a format appropriate for the file type.
+
+        For example, if the file is in text format, this function reads the data from the file at
+        the specified path, parses the text and returns the resulting object. If the file is
+        not in a parsable format or if the file could not be read, this function raises an error.
+        """
+        return cls(_PyExplicitEnvironmentSpec.from_path(path))
+
+    @classmethod
+    def from_str(cls, content: str) -> "ExplicitEnvironmentSpec":
+        """
+        Parses the object from a string containing the explicit environment specification
+
+        Examples:
+
+        ```python
+        >>> spec = ExplicitEnvironmentSpec.from_str('''@EXPLICIT
+        ... # platform: linux-64
+        ... http://repo.anaconda.com/pkgs/main/linux-64/python-3.9.0-h3.tar.bz2
+        ... ''')
+        >>> spec.platform
+        Platform(linux-64)
+        >>> spec.packages[0].url
+        'http://repo.anaconda.com/pkgs/main/linux-64/python-3.9.0-h3.tar.bz2'
+        >>>
+        ```
+        """
+        return cls(_PyExplicitEnvironmentSpec.from_str(content))
+
+    @property
+    def platform(self) -> Optional[Platform]:
+        """Returns the platform specified in the explicit environment specification"""
+        platform = self._inner.platform()
+        if platform is not None:
+            return Platform._from_py_platform(platform)
+        return None
+
+    @property
+    def packages(self) -> List[ExplicitEnvironmentEntry]:
+        """Returns the environment entries (URLs) specified in the explicit environment specification"""
+        return [ExplicitEnvironmentEntry(p) for p in self._inner.packages()]

rattler/index/__init__.py

@@ -0,0 +1,3 @@
+from rattler.index.index import index_fs, index_s3, S3Credentials
+
+__all__ = ["index_s3", "index_fs", "S3Credentials"]

rattler/index/index.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from typing import Optional, Literal
+
+from rattler.platform import Platform
+from rattler.rattler import py_index_fs, py_index_s3
+
+
+@dataclass
+class S3Credentials:
+    """Credentials for accessing an S3 backend."""
+
+    # The endpoint URL of the S3 backend
+    endpoint_url: str
+
+    # The region of the S3 backend
+    region: str
+
+    # The access key ID for the S3 bucket.
+    access_key_id: Optional[str] = None
+
+    # The secret access key for the S3 bucket.
+    secret_access_key: Optional[str] = None
+
+    # The session token for the S3 bucket.
+    session_token: Optional[str] = None
+
+    # Defines how to address the bucket, either using virtual-hosted-style or path-style.
+    addressing_style: Literal["path", "virtual-host"] = "virtual-host"
+
+
+async def index_fs(
+    channel_directory: os.PathLike[str],
+    target_platform: Optional[Platform] = None,
+    repodata_patch: Optional[str] = None,
+    write_zst: bool = True,
+    write_shards: bool = True,
+    force: bool = False,
+    max_parallel: int | None = None,
+) -> None:
+    """
+    Indexes dependencies in the `channel_directory` for one or more subdirectories within said directory.
+    Will generate repodata.json files in each subdirectory containing metadata about each present package,
+    or if `target_platform` is specified will only consider the subdirectory corresponding to this platform.
+    Will always index the "noarch" subdirectory, and thus this subdirectory should always be present, because
+    conda channels at a minimum must include this subdirectory.
+
+    Arguments:
+        channel_directory: A `os.PathLike[str]` that is the directory containing subdirectories
+                           of dependencies to index.
+        target_platform: A `Platform` to index dependencies for.
+        repodata_patch: The name of the conda package (expected to be in the `noarch` subdir) that should be used for repodata patching.
+        write_zst: Whether to write repodata.json.zst.
+        write_shards: Whether to write sharded repodata.
+        force: Whether to forcefully re-index all subdirs.
+        max_parallel: The maximum number of packages to process in-memory simultaneously.
+    """
+    await py_index_fs(
+        channel_directory,
+        target_platform._inner if target_platform else target_platform,
+        repodata_patch,
+        write_zst,
+        write_shards,
+        force,
+        max_parallel,
+    )
+
+
+async def index_s3(
+    channel_url: str,
+    credentials: Optional[S3Credentials] = None,
+    target_platform: Optional[Platform] = None,
+    repodata_patch: Optional[str] = None,
+    write_zst: bool = True,
+    write_shards: bool = True,
+    force: bool = False,
+    max_parallel: int | None = None,
+    precondition_checks: bool = True,
+) -> None:
+    """
+    Indexes dependencies in the `channel_url` for one or more subdirectories in the S3 directory.
+    Will generate repodata.json files in each subdirectory containing metadata about each present package,
+    or if `target_platform` is specified will only consider the subdirectory corresponding to this platform.
+    Will always index the "noarch" subdirectory, and thus this subdirectory should always be present, because
+    conda channels at a minimum must include this subdirectory.
+
+    Arguments:
+        channel_url: An S3 URL (e.g., s3://my-bucket/my-channel that containins the subdirectories
+                     of dependencies to index.
+        credentials: The credentials to use for accessing the S3 bucket. If not provided, will use the default
+                     credentials from the environment.
+        target_platform: A `Platform` to index dependencies for.
+        repodata_patch: The name of the conda package (expected to be in the `noarch` subdir) that should be used for repodata patching.
+        write_zst: Whether to write repodata.json.zst.
+        write_shards: Whether to write sharded repodata.
+        force: Whether to forcefully re-index all subdirs.
+        max_parallel: The maximum number of packages to process in-memory simultaneously.
+        precondition_checks: Whether to perform precondition checks before indexing on S3 buckets which helps to prevent data corruption when indexing with multiple processes at the same time.  Defaults to True.
+    """
+    await py_index_s3(
+        channel_url,
+        credentials,
+        target_platform._inner if target_platform else target_platform,
+        repodata_patch,
+        write_zst,
+        write_shards,
+        force,
+        max_parallel,
+        precondition_checks,
+    )

rattler/install/__init__.py

@@ -0,0 +1,3 @@
+from rattler.install.installer import install
+
+__all__ = ["install"]

rattler/install/installer.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+import os
+from typing import List, Optional
+
+from rattler.match_spec import MatchSpec
+from rattler.networking.client import Client
+from rattler.platform.platform import Platform
+from rattler.prefix.prefix_record import PrefixRecord
+from rattler.repo_data.record import RepoDataRecord
+
+from rattler.rattler import py_install
+
+
+async def install(
+    records: List[RepoDataRecord],
+    target_prefix: str | os.PathLike[str],
+    cache_dir: Optional[os.PathLike[str]] = None,
+    installed_packages: Optional[List[PrefixRecord]] = None,
+    reinstall_packages: Optional[set[str]] = None,
+    ignored_packages: Optional[set[str]] = None,
+    platform: Optional[Platform] = None,
+    execute_link_scripts: bool = False,
+    show_progress: bool = True,
+    client: Optional[Client] = None,
+    requested_specs: Optional[List[MatchSpec]] = None,
+) -> None:
+    """
+    Create an environment by downloading and linking the `dependencies` in
+    the `target_prefix` directory.
+
+    !!! warning
+
+        When `execute_link_scripts` is set to `True` the post-link and pre-unlink scripts of
+        packages will be executed. These scripts are not sandboxed and can be used to execute
+        arbitrary code. It is therefor discouraged to enable executing link scripts.
+
+    Example
+    -------
+    ```python
+    >>> import asyncio
+    >>> from rattler import solve, install
+    >>> from tempfile import TemporaryDirectory
+    >>> temp_dir = TemporaryDirectory()
+    >>>
+    >>> async def main():
+    ...     # Solve an environment with python 3.9 for the current platform
+    ...     records = await solve(sources=["conda-forge"], specs=["python 3.9.*"])
+    ...
+    ...     # Link the environment in a temporary directory (you can pass any kind of path here).
+    ...     await install(records, target_prefix=temp_dir.name)
+    ...
+    ...     # That's it! The environment is now created.
+    ...     # You will find Python under `f"{temp_dir.name}/bin/python"` or `f"{temp_dir.name}/python.exe"` on Windows.
+    >>> asyncio.run(main())
+
+    ```
+
+    Arguments:
+        records: A list of solved `RepoDataRecord`s.
+        target_prefix: Path to the directory where the environment should
+                be created.
+        cache_dir: Path to directory where the dependencies will be
+                downloaded and cached.
+        installed_packages: A list of `PrefixRecord`s which are
+                already installed in the `target_prefix`. This can be obtained by loading
+                `PrefixRecord`s from `{target_prefix}/conda-meta/`.
+                If `None` is specified then the `target_prefix` will be scanned for installed
+                packages.
+        reinstall_packages: A list of package names that should be reinstalled.
+        ignored_packages: A list of package names that should be ignored (left untouched).
+                These packages will not be removed, installed, or updated.
+        platform: Target platform to create and link the
+                environment. Defaults to current platform.
+        execute_link_scripts: whether to execute the post-link and pre-unlink scripts
+                that may be part of a package. Defaults to False.
+        show_progress: If set to `True` a progress bar will be shown on the CLI.
+        client: An authenticated client to use for downloading packages. If not specified a default
+                client will be used.
+        requested_specs: A list of `MatchSpec`s that were originally requested. These will be used
+                to populate the `requested_specs` field in the generated `conda-meta/*.json` files.
+                If `None`, the `requested_specs` field will remain empty.
+    """
+
+    await py_install(
+        records=records,
+        target_prefix=str(target_prefix),
+        cache_dir=cache_dir,
+        installed_packages=installed_packages,
+        reinstall_packages=reinstall_packages,
+        ignored_packages=ignored_packages,
+        platform=platform._inner if platform is not None else None,
+        client=client._client if client is not None else None,
+        execute_link_scripts=execute_link_scripts,
+        show_progress=show_progress,
+        requested_specs=requested_specs,
+    )

rattler/lock/__init__.py

@@ -0,0 +1,23 @@
+from rattler.lock.lock_file import LockFile
+from rattler.lock.environment import Environment
+from rattler.lock.channel import LockChannel
+from rattler.lock.hash import PackageHashes
+from rattler.lock.package import (
+    LockedPackage,
+    PypiLockedPackage,
+    CondaLockedPackage,
+    CondaLockedBinaryPackage,
+    CondaLockedSourcePackage,
+)
+
+__all__ = [
+    "LockFile",
+    "Environment",
+    "LockChannel",
+    "PackageHashes",
+    "LockedPackage",
+    "PypiLockedPackage",
+    "CondaLockedPackage",
+    "CondaLockedBinaryPackage",
+    "CondaLockedSourcePackage",
+]

rattler/lock/channel.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from rattler.rattler import PyLockChannel
+
+
+class LockChannel:
+    _channel: PyLockChannel
+
+    def __init__(self, url: str) -> None:
+        """
+        Create a new channel.
+        """
+        self._channel = PyLockChannel(url)
+
+    @classmethod
+    def _from_py_lock_channel(cls, channel: PyLockChannel) -> LockChannel:
+        """
+        Construct Rattler LockChannel from FFI PyLockChannel object.
+        """
+        chan = cls.__new__(cls)
+        chan._channel = channel
+        return chan
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the LockChannel.
+
+        Examples
+        --------
+        ```python
+        >>> channel = LockChannel("https://conda.anaconda.org/conda-forge/")
+        >>> str(channel)
+        'https://conda.anaconda.org/conda-forge/'
+        >>>
+        ```
+        """
+        return self._channel.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the LockChannel.
+
+        Examples
+        --------
+        ```python
+        >>> channel = LockChannel("https://conda.anaconda.org/conda-forge/")
+        >>> channel
+        LockChannel(url="https://conda.anaconda.org/conda-forge/")
+        >>>
+        ```
+        """
+        return f'LockChannel(url="{self._channel.as_str()}")'

rattler/lock/environment.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+from typing import Dict, List, Optional
+
+from rattler.lock.channel import LockChannel
+from rattler.lock.package import LockedPackage, PypiLockedPackage
+from rattler.platform.platform import Platform
+
+from rattler.rattler import PyEnvironment
+from rattler.repo_data.record import RepoDataRecord
+
+
+class Environment:
+    """
+    Information about a specific environment in the lock-file.
+    """
+
+    _env: PyEnvironment
+
+    def __init__(
+        self, name: str, requirements: Dict[Platform, List[RepoDataRecord]], channels: List[LockChannel]
+    ) -> None:
+        """
+        Create a new environment.
+        """
+        self._env = PyEnvironment(
+            name=name,
+            # TODO: move this logic to rust
+            records={
+                platform._inner: [record._record for record in records] for (platform, records) in requirements.items()
+            },
+            channels=[channel._channel for channel in channels],
+        )
+
+    def platforms(self) -> List[Platform]:
+        """
+        Returns all the platforms for which we have a locked-down environment.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import LockFile
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> env.platforms()
+        [...]
+        >>>
+        ```
+        """
+        return [Platform._from_py_platform(p) for p in self._env.platforms()]
+
+    def channels(self) -> List[LockChannel]:
+        """
+        Returns the channels that are used by this environment.
+        Note that the order of the channels is significant.
+        The first channel is the highest priority channel.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import LockFile
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> env.channels()
+        [LockChannel(url="https://conda.anaconda.org/conda-forge/")]
+        >>>
+        ```
+        """
+        return [LockChannel._from_py_lock_channel(c) for c in self._env.channels()]
+
+    def packages(self, platform: Platform) -> Optional[List[LockedPackage]]:
+        """
+        Returns all the packages for a specific platform in this environment.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import Platform, LockFile
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> env.packages(Platform("osx-arm64"))[0]
+        CondaLockedBinaryPackage(name='tzdata',location='https://conda.anaconda.org/conda-forge/noarch/tzdata-2024a-h0c530f3_0.conda')
+        >>>
+        ```
+        """
+        if packages := self._env.packages(platform._inner):
+            return [LockedPackage._from_py_locked_package(p) for p in packages]
+        return None
+
+    def packages_by_platform(self) -> Dict[Platform, List[LockedPackage]]:
+        """
+        Returns a list of all packages and platforms defined for this environment.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import LockFile
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> pkgs = env.packages_by_platform()
+        >>> list(pkgs.keys())
+        [Platform(...)]
+        >>>
+        ```
+        """
+        return {
+            Platform._from_py_platform(platform): [LockedPackage._from_py_locked_package(p) for p in packages]
+            for (platform, packages) in self._env.packages_by_platform()
+        }
+
+    def pypi_packages(
+        self,
+    ) -> Dict[Platform, List[PypiLockedPackage]]:
+        """
+        Returns all pypi packages for all platforms.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import LockFile, Platform
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> pypi_packages = env.pypi_packages()
+        >>> pypi_packages[Platform("osx-arm64")][0]
+        PypiLockedPackage(name='charset-normalizer',location='https://files.pythonhosted.org/packages/3a/52/9f9d17c3b54dc238de384c4cb5a2ef0e27985b42a0e5cc8e8a31d918d48d/charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl#sha256=55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6')
+        >>>
+        ```
+        """
+        return {
+            Platform._from_py_platform(platform): [PypiLockedPackage._from_py_locked_package(pypi) for pypi in pypi_tup]
+            for (platform, pypi_tup) in self._env.pypi_packages().items()
+        }
+
+    def conda_repodata_records(self) -> Dict[Platform, List[RepoDataRecord]]:
+        """
+        Returns all conda packages for all platforms.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import LockFile
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> env.conda_repodata_records()
+        {'osx-arm64': [RepoDataRecord(...), ...]}
+        >>>
+        ```
+        """
+        return {
+            platform.name: [RepoDataRecord._from_py_record(r) for r in records]
+            for (platform, records) in self._env.conda_repodata_records().items()
+        }
+
+    def conda_repodata_records_for_platform(self, platform: Platform) -> Optional[List[RepoDataRecord]]:
+        """
+        Takes all the conda packages, converts them to [`RepoDataRecord`] and returns them or
+        returns an error if the conversion failed. Returns `None` if the specified platform is not
+        defined for this environment.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import LockFile, Platform
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> rdr = env.conda_repodata_records_for_platform(Platform("osx-arm64"))
+        >>> rdr
+        [...]
+        >>> rdr[0]
+        RepoDataRecord(...)
+        >>>
+        ```
+        """
+        if records := self._env.conda_repodata_records_for_platform(platform._inner):
+            return [RepoDataRecord._from_py_record(r) for r in records]
+        return None
+
+    def pypi_packages_for_platform(self, platform: Platform) -> Optional[List[PypiLockedPackage]]:
+        """
+        Returns all the pypi packages and their associated environment data for the specified
+        platform. Returns `None` if the platform is not defined for this environment.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import LockFile, Platform
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> osx_pypi_pkgs = env.pypi_packages_for_platform(Platform("osx-arm64"))
+        >>> osx_pypi_pkgs
+        [...]
+        >>> osx_pypi_pkgs[0]
+        PypiLockedPackage(name='charset-normalizer',location='https://files.pythonhosted.org/packages/3a/52/9f9d17c3b54dc238de384c4cb5a2ef0e27985b42a0e5cc8e8a31d918d48d/charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl#sha256=55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6')
+        >>>
+        ```
+        """
+        if data := self._env.pypi_packages_for_platform(platform._inner):
+            return [PypiLockedPackage._from_py_locked_package(pkg) for pkg in data]
+        return None
+
+    @classmethod
+    def _from_py_environment(cls, py_environment: PyEnvironment) -> Environment:
+        """
+        Construct Rattler Environment from FFI PyEnvironment object.
+        """
+        env = cls.__new__(cls)
+        env._env = py_environment
+        return env
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the Environment.
+        """
+        return "Environment()"

rattler/lock/hash.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from typing import Optional
+from rattler.rattler import PyPackageHashes
+
+
+class PackageHashes:
+    _hashes: PyPackageHashes
+
+    @property
+    def md5(self) -> Optional[bytes]:
+        """
+        Returns the Sha256 hash.
+        """
+        return self._hashes.md5
+
+    @property
+    def sha256(self) -> Optional[bytes]:
+        """
+        Returns the Sha256 hash.
+        """
+        return self._hashes.sha256
+
+    @classmethod
+    def _from_py_package_hashes(cls, pkg_hashes: PyPackageHashes) -> PackageHashes:
+        """
+        Construct Rattler PackageHashes from FFI PyPackageHashes object.
+        """
+        hashes = cls.__new__(cls)
+        hashes._hashes = pkg_hashes
+        return hashes
+
+    def __repr__(self) -> str:
+        return "PackageHashes()"