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

rattler/shell/__init__.py

@@ -0,0 +1,3 @@
+from rattler.shell.shell import ActivationVariables, activate, Shell, PathModificationBehavior
+
+__all__ = ["ActivationVariables", "activate", "Shell", "PathModificationBehavior"]

rattler/shell/shell.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+from enum import Enum
+
+from typing import Iterable, Optional
+from pathlib import Path
+import os
+from rattler.platform.platform import Platform, PlatformLiteral
+
+from rattler.rattler import (
+    PyActivationVariables,
+    PyActivator,
+    PyShellEnum,
+    PyActivationResult,
+)
+
+
+class PathModificationBehavior(Enum):
+    """
+    The behavior to use when modifying the PATH environment variable.
+    Prepend will add the new path to the beginning of the PATH variable.
+    Append will add the new path to the end of the PATH variable.
+    Replace will replace the entire PATH variable with the new path.
+    """
+
+    Prepend = "prepend"
+    Append = "append"
+    Replace = "replace"
+
+
+class ActivationVariables:
+    """An object that holds the state of the current environment."""
+
+    def __init__(
+        self,
+        current_prefix: Optional[os.PathLike[str]] = None,
+        current_path: Optional[Iterable[str] | Iterable[os.PathLike[str]]] | None = None,
+        path_modification_behavior: PathModificationBehavior = PathModificationBehavior.Prepend,
+    ) -> None:
+        """
+        Construct a new ActivationVariables object.
+
+        current_prefix: The current activated conda prefix (usually
+            `os.environ["CONDA_PREFIX"]`). This prefix is going to be deactivated.
+        current_path: The current PATH environment variable (usually
+            `os.environ["PATH"].split(os.pathsep)`).
+        path_modification_behavior: The behavior to use when modifying the PATH
+            environment variable. One of "Prepend", "Append", or "Replace".
+            Defaults to "Prepend".
+        """
+        self._activation_variables = PyActivationVariables(
+            current_prefix,
+            current_path or os.environ.get("PATH", "").split(os.pathsep),
+            path_modification_behavior.value,
+        )
+
+    def __str__(self) -> str:
+        return self._activation_variables.as_str()
+
+
+class ActivationResult:
+    """An object that holds the result of activating a conda environment."""
+
+    _py_activation_result: PyActivationResult
+
+    @classmethod
+    def _from_py_activation_result(cls, py_activation_result: PyActivationResult) -> ActivationResult:
+        """Construct Rattler version from FFI PyActivationResult object."""
+        activation_result = cls.__new__(cls)
+        activation_result._py_activation_result = py_activation_result
+        return activation_result
+
+    @property
+    def path(self) -> Path:
+        """The new PATH environment variable."""
+        return self._py_activation_result.path
+
+    @property
+    def script(self) -> str:
+        """The script to run to activate the environment."""
+        return self._py_activation_result.script
+
+
+class Shell:
+    """An enum of supported shells."""
+
+    bash = PyShellEnum.Bash
+    zsh = PyShellEnum.Zsh
+    fish = PyShellEnum.Fish
+    xonsh = PyShellEnum.Xonsh
+    powershell = PyShellEnum.PowerShell
+    cmd_exe = PyShellEnum.CmdExe
+
+
+def activate(
+    prefix: Path,
+    activation_variables: ActivationVariables,
+    shell: Optional[Shell] = None,
+    platform: Optional[Platform | PlatformLiteral] = None,
+) -> ActivationResult:
+    """
+    Return an ActivationResult object that contains the new PATH environment variable
+    and the script to run to activate the environment.
+
+    Arguments:
+        prefix: The path to the conda prefix to activate.
+        activation_variables: The current activation variables.
+        shell: The shell to generate the activation script for.
+        platform: The platform to generate the activation script for.
+                  If None, the current platform is used.
+
+    Returns:
+        An ActivationResult object containing the new PATH environment variable
+        and the script to run to activate the environment.
+
+    Examples
+    --------
+    ```python
+    >>> from rattler.shell import Shell, activate, ActivationVariables
+    >>> from rattler.platform import Platform
+    >>> from pathlib import Path
+    >>> import sys
+    >>> p = Path("/path/to/conda/prefix")
+    >>> actvars = ActivationVariables()
+    >>> a = activate(p, actvars, Shell.xonsh)
+    >>> print(a)
+    <rattler.shell.shell.ActivationResult object at ...>
+    >>>
+    ```
+    """
+    platform = Platform(platform) if isinstance(platform, str) else platform or Platform.current()
+    shell = shell or Shell.bash
+    return ActivationResult._from_py_activation_result(
+        PyActivator.activate(prefix, activation_variables._activation_variables, platform._inner, shell)
+    )

rattler/solver/__init__.py

@@ -0,0 +1,3 @@
+from rattler.solver.solver import solve, solve_with_sparse_repodata
+
+__all__ = ["solve", "solve_with_sparse_repodata"]

rattler/solver/solver.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, List, Literal, Optional, Sequence, Union
+
+from rattler.channel.channel import Channel
+from rattler.channel.channel_priority import ChannelPriority
+from rattler.match_spec.match_spec import MatchSpec
+from rattler.platform.platform import Platform, PlatformLiteral
+from rattler.rattler import PyMatchSpec, py_solve, py_solve_with_sparse_repodata
+from rattler.repo_data.gateway import Gateway, _convert_sources
+from rattler.repo_data.record import RepoDataRecord
+from rattler.repo_data.sparse import SparseRepoData, PackageFormatSelection
+from rattler.virtual_package.generic import GenericVirtualPackage
+from rattler.virtual_package.virtual_package import VirtualPackage
+
+if TYPE_CHECKING:
+    from rattler.repo_data.source import RepoDataSource
+
+SolveStrategy = Literal["highest", "lowest", "lowest-direct"]
+"""Defines the strategy to use when multiple versions of a package are available during solving."""
+
+
+async def solve(
+    sources: Sequence[Union[Channel, str, RepoDataSource]],
+    specs: Sequence[MatchSpec | str],
+    gateway: Gateway = Gateway(),
+    platforms: Optional[Sequence[Platform | PlatformLiteral]] = None,
+    locked_packages: Optional[Sequence[RepoDataRecord]] = None,
+    pinned_packages: Optional[Sequence[RepoDataRecord]] = None,
+    virtual_packages: Optional[Sequence[GenericVirtualPackage | VirtualPackage]] = None,
+    timeout: Optional[datetime.timedelta] = None,
+    channel_priority: ChannelPriority = ChannelPriority.Strict,
+    exclude_newer: Optional[datetime.datetime] = None,
+    strategy: SolveStrategy = "highest",
+    constraints: Optional[Sequence[MatchSpec | str]] = None,
+) -> List[RepoDataRecord]:
+    """
+    Resolve the dependencies and return the `RepoDataRecord`s
+    that should be present in the environment.
+
+    Arguments:
+        sources: The sources to query for the packages. Can be channels (by name, URL,
+                 or Channel object) or custom RepoDataSource implementations.
+        specs: A list of matchspec to solve.
+        platforms: The platforms to query for the packages. If `None` the current platform and
+                `noarch` is used.
+        gateway: The gateway to use for acquiring repodata.
+        locked_packages: Records of packages that are previously selected.
+                 If the solver encounters multiple variants of a single
+                 package (identified by its name), it will sort the records
+                 and select the best possible version. However, if there
+                 exists a locked version it will prefer that variant instead.
+                 This is useful to reduce the number of packages that are
+                 updated when installing new packages. Usually you add the
+                 currently installed packages or packages from a lock-file here.
+        pinned_packages: Records of packages that are previously selected and CANNOT
+                 be changed. If the solver encounters multiple variants of
+                 a single package (identified by its name), it will sort the
+                 records and select the best possible version. However, if
+                 there is a variant available in the `pinned_packages` field it
+                 will always select that version no matter what even if that
+                 means other packages have to be downgraded.
+        virtual_packages: A list of virtual packages considered active.
+        channel_priority: (Default = ChannelPriority.Strict) When `ChannelPriority.Strict`
+                 the channel that the package is first found in will be used as
+                 the only channel for that package. When `ChannelPriority.Disabled`
+                 it will search for every package in every channel.
+        timeout:    The maximum time the solver is allowed to run.
+        exclude_newer: Exclude any record that is newer than the given datetime.
+        strategy: The strategy to use when multiple versions of a package are available.
+
+            * `"highest"`: Select the highest compatible version of all packages.
+            * `"lowest"`: Select the lowest compatible version of all packages.
+            * `"lowest-direct"`: Select the lowest compatible version for all
+              direct dependencies but the highest compatible version of transitive
+              dependencies.
+        constraints: Additional constraints that should be satisfied by the solver.
+            Packages included in the `constraints` are not necessarily installed,
+            but they must be satisfied by the solution.
+
+    Returns:
+        Resolved list of `RepoDataRecord`s.
+    """
+
+    platforms = platforms if platforms is not None else [Platform.current(), Platform("noarch")]
+
+    return [
+        RepoDataRecord._from_py_record(solved_package)
+        for solved_package in await py_solve(
+            sources=_convert_sources(sources),
+            platforms=[
+                platform._inner if isinstance(platform, Platform) else Platform(platform)._inner
+                for platform in platforms
+            ],
+            specs=[
+                spec._match_spec if isinstance(spec, MatchSpec) else PyMatchSpec(str(spec), True, True)
+                for spec in specs
+            ],
+            gateway=gateway._gateway,
+            locked_packages=[package._record for package in locked_packages or []],
+            pinned_packages=[package._record for package in pinned_packages or []],
+            virtual_packages=[
+                v_package.into_generic()._generic_virtual_package
+                if isinstance(v_package, VirtualPackage)
+                else v_package._generic_virtual_package
+                for v_package in virtual_packages or []
+            ],
+            channel_priority=channel_priority.value,
+            timeout=int(timeout / datetime.timedelta(microseconds=1)) if timeout else None,
+            exclude_newer_timestamp_ms=int(exclude_newer.replace(tzinfo=datetime.timezone.utc).timestamp() * 1000)
+            if exclude_newer
+            else None,
+            strategy=strategy,
+            constraints=[
+                constraint._match_spec
+                if isinstance(constraint, MatchSpec)
+                else PyMatchSpec(str(constraint), True, True)
+                for constraint in constraints
+            ]
+            if constraints is not None
+            else [],
+        )
+    ]
+
+
+async def solve_with_sparse_repodata(
+    specs: Sequence[MatchSpec | str],
+    sparse_repodata: Sequence[SparseRepoData],
+    locked_packages: Optional[Sequence[RepoDataRecord]] = None,
+    pinned_packages: Optional[Sequence[RepoDataRecord]] = None,
+    virtual_packages: Optional[Sequence[GenericVirtualPackage | VirtualPackage]] = None,
+    timeout: Optional[datetime.timedelta] = None,
+    channel_priority: ChannelPriority = ChannelPriority.Strict,
+    exclude_newer: Optional[datetime.datetime] = None,
+    strategy: SolveStrategy = "highest",
+    constraints: Optional[Sequence[MatchSpec | str]] = None,
+    package_format_selection: PackageFormatSelection = PackageFormatSelection.PREFER_CONDA,
+) -> List[RepoDataRecord]:
+    """
+    Resolve the dependencies and return the `RepoDataRecord`s
+    that should be present in the environment.
+
+    This function is similar to `solve` but instead of querying for repodata
+    with a `Gateway` object this function allows you to manually pass in the
+    repodata.
+
+    Arguments:
+        specs: A list of matchspec to solve.
+        sparse_repodata: The repodata to query for the packages.
+        locked_packages: Records of packages that are previously selected.
+                 If the solver encounters multiple variants of a single
+                 package (identified by its name), it will sort the records
+                 and select the best possible version. However, if there
+                 exists a locked version it will prefer that variant instead.
+                 This is useful to reduce the number of packages that are
+                 updated when installing new packages. Usually you add the
+                 currently installed packages or packages from a lock-file here.
+        pinned_packages: Records of packages that are previously selected and CANNOT
+                 be changed. If the solver encounters multiple variants of
+                 a single package (identified by its name), it will sort the
+                 records and select the best possible version. However, if
+                 there is a variant available in the `pinned_packages` field it
+                 will always select that version no matter what even if that
+                 means other packages have to be downgraded.
+        virtual_packages: A list of virtual packages considered active.
+        channel_priority: (Default = ChannelPriority.Strict) When `ChannelPriority.Strict`
+                 the channel that the package is first found in will be used as
+                 the only channel for that package. When `ChannelPriority.Disabled`
+                 it will search for every package in every channel.
+        timeout:    The maximum time the solver is allowed to run.
+        exclude_newer: Exclude any record that is newer than the given datetime.
+        strategy: The strategy to use when multiple versions of a package are available.
+
+            * `"highest"`: Select the highest compatible version of all packages.
+            * `"lowest"`: Select the lowest compatible version of all packages.
+            * `"lowest-direct"`: Select the lowest compatible version for all
+              direct dependencies but the highest compatible version of transitive
+              dependencies.
+        constraints: Additional constraints that should be satisfied by the solver.
+            Packages included in the `constraints` are not necessarily installed,
+            but they must be satisfied by the solution.
+        package_format_selection: Defines which package formats are selected
+
+    Returns:
+        Resolved list of `RepoDataRecord`s.
+    """
+    return [
+        RepoDataRecord._from_py_record(solved_package)
+        for solved_package in await py_solve_with_sparse_repodata(
+            specs=[
+                spec._match_spec if isinstance(spec, MatchSpec) else PyMatchSpec(str(spec), True, True)
+                for spec in specs
+            ],
+            sparse_repodata=[package._sparse for package in sparse_repodata],
+            locked_packages=[package._record for package in locked_packages or []],
+            pinned_packages=[package._record for package in pinned_packages or []],
+            virtual_packages=[
+                v_package.into_generic()._generic_virtual_package
+                if isinstance(v_package, VirtualPackage)
+                else v_package._generic_virtual_package
+                for v_package in virtual_packages or []
+            ],
+            channel_priority=channel_priority.value,
+            timeout=int(timeout / datetime.timedelta(microseconds=1)) if timeout else None,
+            package_format_selection=package_format_selection.value,
+            exclude_newer_timestamp_ms=int(exclude_newer.replace(tzinfo=datetime.timezone.utc).timestamp() * 1000)
+            if exclude_newer
+            else None,
+            strategy=strategy,
+            constraints=[
+                constraint._match_spec
+                if isinstance(constraint, MatchSpec)
+                else PyMatchSpec(str(constraint), True, True)
+                for constraint in constraints
+            ]
+            if constraints is not None
+            else [],
+        )
+    ]

rattler/utils/rattler_version.py

@@ -0,0 +1,19 @@
+try:
+    from rattler.rattler import get_rattler_version as _get_rattler_version
+
+    rattler_version_string = _get_rattler_version()
+except ImportError:
+    # this is only useful for documentation
+    import warnings
+
+    warnings.warn("rattler binary missing!", stacklevel=2)
+    rattler_version_string = ""
+
+
+def get_rattler_version() -> str:
+    """
+    Return the version of the Python Rattler package as a string.
+
+    If the Rattler binary is missing, returns an empty string.
+    """
+    return rattler_version_string

rattler/version/__init__.py

@@ -0,0 +1,5 @@
+from rattler.version.version import Version
+from rattler.version.version_spec import VersionSpec
+from rattler.version.with_source import VersionWithSource
+
+__all__ = ["Version", "VersionSpec", "VersionWithSource"]