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

rattler/match_spec/match_spec.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from rattler.channel.channel import Channel
+from rattler.package.package_name_matcher import PackageNameMatcher
+from rattler.rattler import PyMatchSpec
+
+if TYPE_CHECKING:
+    from rattler.match_spec import NamelessMatchSpec
+    from rattler.repo_data import PackageRecord
+
+
+class MatchSpec:
+    """
+    A `MatchSpec` is a query language for conda packages.
+    It can be composed of any of the attributes of `PackageRecord`.
+
+    `MatchSpec` can be composed of keyword arguments, where keys are
+    any of the attributes of `PackageRecord`. Values for keyword arguments
+    are exact values the attributes should match against. Many fields can
+    be matched against non-exact values by including wildcard `*` and `>`/`<`
+    ranges where supported. Any non-specified field is the equivalent of a
+    full wildcard match.
+
+    MatchSpecs can also be composed using a single positional argument, with optional
+    keyword arguments. Keyword arguments also override any conflicting information
+    provided in the positional argument. Conda has historically had several string
+    representations for equivalent MatchSpecs.
+
+    A series of rules are now followed for creating the canonical string
+    representation of a MatchSpec instance. The canonical string representation can
+    generically be represented by:
+
+    `(channel(/subdir):(namespace):)name(version(build))[key1=value1,key2=value2]`
+
+    where `()` indicate optional fields.
+
+    The rules for constructing a canonical string representation are:
+
+    1. `name` (i.e. "package name") is required, but its value can be '*'. Its
+    position is always outside the key-value brackets.
+    It can also be a glob pattern or a regex if `exact_names_only` is `False`.
+    2. If `version` is an exact version, it goes outside the key-value brackets and
+    is prepended by `==`. If `version` is a "fuzzy" value (e.g. `1.11.*`), it goes
+    outside the key-value brackets with the `.*` left off and is prepended by `=`.
+    Otherwise `version` is included inside key-value brackets.
+    3. If `version` is an exact version, and `build` is an exact value, `build` goes
+    outside key-value brackets prepended by a `=`.  Otherwise, `build` goes inside
+    key-value brackets. `build_string` is an alias for `build`.
+    4. The `namespace` position is being held for a future feature. It is currently
+    ignored.
+    5. If `channel` is included and is an exact value, a `::` separator is used between
+    `channel` and `name`.  `channel` can either be a canonical channel name or a
+    channel url. In the canonical string representation, the canonical channel name
+    will always be used.
+    6. If `channel` is an exact value and `subdir` is an exact value, `subdir` is
+    appended to `channel` with a `/` separator.  Otherwise, `subdir` is included in
+    the key-value brackets.
+    7. Key-value brackets can be delimited by comma, space, or comma+space. Value can
+    optionally be wrapped in single or double quotes, but must be wrapped if `value`
+    contains a comma, space, or equal sign.  The canonical format uses comma delimiters
+    and single quotes.
+    8. When constructing a `MatchSpec` instance from a string, any key-value pair given
+    inside the key-value brackets overrides any matching parameter given outside the
+    brackets.
+
+    When `MatchSpec` attribute values are simple strings, the are interpreted using the
+    following conventions:
+    - If the string begins with `^` and ends with `$`, it is converted to a regex.
+    - If the string contains an asterisk (`*`), it is transformed from a glob to a
+    regex.
+    - Otherwise, an exact match to the string is sought.
+
+    To fully-specify a package with a full, exact spec, the following fields must be
+    given as exact values:
+    - channel
+    - subdir
+    - name
+    - version
+    - build
+    """
+
+    def __init__(
+        self,
+        spec: str,
+        strict: bool = False,
+        exact_names_only: bool = True,
+        experimental_extras: bool = False,
+        experimental_conditionals: bool = False,
+    ) -> None:
+        """
+        Create a new version spec.
+
+        When `strict` is `True`, some ambiguous version specs are rejected.
+
+        When `experimental_extras` is `True`, extras syntax is enabled (e.g., `pkg[extras=[foo,bar]]`).
+
+        When `experimental_conditionals` is `True`, conditionals syntax is enabled (e.g., `pkg; if python >=3.6`).
+
+        ```python
+        >>> MatchSpec("pip >=24.0")
+        MatchSpec("pip >=24.0")
+        >>> MatchSpec("pip 24")
+        MatchSpec("pip ==24")
+        >>> MatchSpec("python[license=MIT]")
+        MatchSpec("python[license="MIT"]")
+        >>> MatchSpec("foo*", strict=True, exact_names_only=False)
+        MatchSpec("foo*")
+        >>> MatchSpec("^foo.*$", strict=True, exact_names_only=True) # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        InvalidMatchSpecException: "^foo.*$" looks like a regex but only exact package names are allowed, package names can only contain 0-9, a-z, A-Z, -, _, or .
+        >>>
+        ```
+        """
+        if isinstance(spec, str):
+            self._match_spec = PyMatchSpec(
+                spec, strict, exact_names_only, experimental_extras, experimental_conditionals
+            )
+        else:
+            raise TypeError(
+                f"MatchSpec constructor received unsupported type {type(spec).__name__!r} for the 'spec' parameter"
+            )
+
+    @property
+    def name(self) -> Optional[PackageNameMatcher]:
+        """
+        The name of the package.
+        """
+        return PackageNameMatcher._from_py_package_name_matcher(self._match_spec.name)
+
+    @property
+    def version(self) -> Optional[str]:
+        """
+        The version spec of the package (e.g. `1.2.3`, `>=1.2.3`, `1.2.*`)
+        """
+        return self._match_spec.version
+
+    @property
+    def build(self) -> Optional[str]:
+        """
+        The build string of the package (e.g. `py37_0`, `py37h6de7cb9_0`, `py*`)
+        """
+        return self._match_spec.build
+
+    @property
+    def build_number(self) -> Optional[str]:
+        """
+        The build number of the package.
+        """
+        return self._match_spec.build_number
+
+    @property
+    def file_name(self) -> Optional[str]:
+        """
+        Match the specific filename of the package.
+        """
+        return self._match_spec.file_name
+
+    @property
+    def channel(self) -> Optional[Channel]:
+        """
+        The channel of the package.
+        """
+        channel = self._match_spec.channel
+        return channel and Channel._from_py_channel(channel)
+
+    @property
+    def subdir(self) -> Optional[str]:
+        """
+        The subdir of the channel.
+        """
+        return self._match_spec.subdir
+
+    @property
+    def namespace(self) -> Optional[str]:
+        """
+        The namespace of the package.
+        """
+        return self._match_spec.namespace
+
+    @property
+    def extras(self) -> Optional[list[str]]:
+        """
+        The extras (optional dependencies) of the package.
+        """
+        return self._match_spec.extras
+
+    @property
+    def condition(self) -> Optional[str]:
+        """
+        The condition under which this match spec applies.
+        """
+        return self._match_spec.condition
+
+    @property
+    def md5(self) -> Optional[bytes]:
+        """
+        The md5 hash of the package.
+        """
+        return self._match_spec.md5
+
+    @property
+    def sha256(self) -> Optional[bytes]:
+        """
+        The sha256 hash of the package.
+        """
+        return self._match_spec.sha256
+
+    @classmethod
+    def _from_py_match_spec(cls, py_match_spec: PyMatchSpec) -> MatchSpec:
+        """
+        Construct py-rattler MatchSpec from PyMatchSpec FFI object.
+        """
+        match_spec = cls.__new__(cls)
+        match_spec._match_spec = py_match_spec
+
+        return match_spec
+
+    def matches(self, record: PackageRecord) -> bool:
+        """Match a MatchSpec against a PackageRecord."""
+        return self._match_spec.matches(record._record)
+
+    @classmethod
+    def from_nameless(cls, spec: NamelessMatchSpec, name: str) -> MatchSpec:
+        """
+        Constructs a MatchSpec from a NamelessMatchSpec
+        and a name.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import NamelessMatchSpec
+        >>> spec = NamelessMatchSpec('3.4')
+        >>> MatchSpec.from_nameless(spec, "foo")
+        MatchSpec("foo ==3.4")
+        >>> MatchSpec.from_nameless(spec, "$foo") # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        exceptions.PackageNameMatcherParseException
+        >>>
+        ```
+        """
+        return cls._from_py_match_spec(PyMatchSpec.from_nameless(spec._nameless_match_spec, name))
+
+    @classmethod
+    def from_url(cls, url: str) -> MatchSpec:
+        """
+        Constructs a MatchSpec from a URL.
+
+        Examples
+        --------
+        ```python
+        >>> MatchSpec.from_url('https://repo.anaconda.com/pkgs/main/linux-64/python-3.9.0-h3.tar.bz2')
+        MatchSpec("python[url="https://repo.anaconda.com/pkgs/main/linux-64/python-3.9.0-h3.tar.bz2"]")
+        >>> MatchSpec.from_url('https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2#d7c89558ba9fa0495403155b64376d81')
+        MatchSpec("_libgcc_mutex[md5="d7c89558ba9fa0495403155b64376d81", url="https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2"]")
+        >>> MatchSpec.from_url('https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2#sha256:adfa71f158cbd872a36394c56c3568e6034aa55c623634b37a4836bd036e6b91')
+        MatchSpec("_libgcc_mutex[sha256="adfa71f158cbd872a36394c56c3568e6034aa55c623634b37a4836bd036e6b91", url="https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2"]")
+        >>>
+        ```
+        """
+        return cls._from_py_match_spec(PyMatchSpec.from_url(url))
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the MatchSpec.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import NamelessMatchSpec
+        >>> spec = NamelessMatchSpec('3.4')
+        >>> str(MatchSpec.from_nameless(spec, "foo"))
+        'foo ==3.4'
+        >>>
+        ```
+        """
+        return self._match_spec.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the MatchSpec.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import NamelessMatchSpec
+        >>> spec = NamelessMatchSpec('3.4')
+        >>> MatchSpec.from_nameless(spec, "foo")
+        MatchSpec("foo ==3.4")
+        >>>
+        ```
+        """
+        return f'MatchSpec("{self._match_spec.as_str()}")'

rattler/match_spec/nameless_match_spec.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+from rattler.channel.channel import Channel
+
+from rattler.rattler import PyNamelessMatchSpec
+
+if TYPE_CHECKING:
+    from rattler.match_spec import MatchSpec
+    from rattler.repo_data import PackageRecord
+
+
+class NamelessMatchSpec:
+    """
+    Similar to a `MatchSpec` but does not include the package name.
+    This is useful in places where the package name is already known
+    (e.g. `foo = "3.4.1 *cuda"`).
+    """
+
+    def __init__(
+        self,
+        spec: str,
+        strict: bool = False,
+        experimental_extras: bool = False,
+        experimental_conditionals: bool = False,
+    ) -> None:
+        """
+        Create a new version spec.
+
+        When `strict` is `True`, some ambiguous version specs are rejected.
+
+        When `experimental_extras` is `True`, extras syntax is enabled (e.g., `[extras=[foo,bar]]`).
+
+        When `experimental_conditionals` is `True`, conditionals syntax is enabled (e.g., `>=1.0; if python >=3.6`).
+
+        ```python
+        >>> NamelessMatchSpec(">=24.0")
+        NamelessMatchSpec(">=24.0")
+        >>> NamelessMatchSpec("24")
+        NamelessMatchSpec("==24")
+        >>>
+        ```
+        """
+        if isinstance(spec, str):
+            self._nameless_match_spec = PyNamelessMatchSpec(
+                spec, strict, experimental_extras, experimental_conditionals
+            )
+        else:
+            raise TypeError(
+                "NamelessMatchSpec constructor received unsupported type"
+                f" {type(spec).__name__!r} for the 'spec' parameter"
+            )
+
+    @property
+    def version(self) -> Optional[str]:
+        """
+        The version spec of the package (e.g. `1.2.3`, `>=1.2.3`, `1.2.*`)
+        """
+        return self._nameless_match_spec.version
+
+    @property
+    def build(self) -> Optional[str]:
+        """
+        The build string of the package (e.g. `py37_0`, `py37h6de7cb9_0`, `py*`)
+        """
+        return self._nameless_match_spec.build
+
+    @property
+    def build_number(self) -> Optional[str]:
+        """
+        The build number of the package.
+        """
+        return self._nameless_match_spec.build_number
+
+    @property
+    def file_name(self) -> Optional[str]:
+        """
+        Match the specific filename of the package.
+        """
+        return self._nameless_match_spec.file_name
+
+    @property
+    def channel(self) -> Optional[Channel]:
+        """
+        The channel of the package.
+        """
+        channel = self._nameless_match_spec.channel
+        return channel and Channel._from_py_channel(channel)
+
+    @property
+    def subdir(self) -> Optional[str]:
+        """
+        The subdir of the channel.
+        """
+        return self._nameless_match_spec.subdir
+
+    @property
+    def namespace(self) -> Optional[str]:
+        """
+        The namespace of the package.
+        """
+        return self._nameless_match_spec.namespace
+
+    @property
+    def md5(self) -> Optional[bytes]:
+        """
+        The md5 hash of the package.
+        """
+        return self._nameless_match_spec.md5
+
+    @property
+    def sha256(self) -> Optional[bytes]:
+        """
+        The sha256 hash of the package.
+        """
+        return self._nameless_match_spec.sha256
+
+    @property
+    def extras(self) -> Optional[list[str]]:
+        """The extras (optional dependencies) of the package."""
+        return self._nameless_match_spec.extras
+
+    @property
+    def condition(self) -> Optional[str]:
+        """The condition under which this match spec applies."""
+        return self._nameless_match_spec.condition
+
+    def matches(self, package_record: PackageRecord) -> bool:
+        """
+        Match a MatchSpec against a PackageRecord
+        """
+        return self._nameless_match_spec.matches(package_record._record)
+
+    @classmethod
+    def _from_py_nameless_match_spec(cls, py_nameless_match_spec: PyNamelessMatchSpec) -> NamelessMatchSpec:
+        """
+        Construct py-rattler NamelessMatchSpec from PyNamelessMatchSpec FFI object.
+        """
+        nameless_match_spec = cls.__new__(cls)
+        nameless_match_spec._nameless_match_spec = py_nameless_match_spec
+
+        return nameless_match_spec
+
+    @classmethod
+    def from_match_spec(cls, spec: MatchSpec) -> NamelessMatchSpec:
+        """
+        Constructs a NamelessMatchSpec from a MatchSpec.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import MatchSpec
+        >>> NamelessMatchSpec.from_match_spec(MatchSpec("foo ==3.4"))
+        NamelessMatchSpec("==3.4")
+        >>>
+        ```
+        """
+        return cls._from_py_nameless_match_spec(PyNamelessMatchSpec.from_match_spec(spec._match_spec))
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the NamelessMatchSpec.
+
+        Examples
+        --------
+        ```python
+        >>> str(NamelessMatchSpec("3.4"))
+        '==3.4'
+        >>>
+        ```
+        """
+        return self._nameless_match_spec.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the NamelessMatchSpec.
+
+        Examples
+        --------
+        ```python
+        >>> NamelessMatchSpec("3.4")
+        NamelessMatchSpec("==3.4")
+        >>>
+        ```
+        """
+        return f'NamelessMatchSpec("{self._nameless_match_spec.as_str()}")'

rattler/networking/__init__.py

@@ -0,0 +1,21 @@
+from rattler.networking.client import Client
+from rattler.networking.fetch_repo_data import fetch_repo_data, CacheAction, FetchRepoDataOptions
+from rattler.networking.middleware import (
+    AddHeadersMiddleware,
+    AuthenticationMiddleware,
+    GCSMiddleware,
+    MirrorMiddleware,
+    S3Middleware,
+)
+
+__all__ = [
+    "fetch_repo_data",
+    "FetchRepoDataOptions",
+    "CacheAction",
+    "Client",
+    "AddHeadersMiddleware",
+    "MirrorMiddleware",
+    "AuthenticationMiddleware",
+    "S3Middleware",
+    "GCSMiddleware",
+]

rattler/networking/client.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from rattler.networking.middleware import (
+    AddHeadersMiddleware,
+    AuthenticationMiddleware,
+    GCSMiddleware,
+    MirrorMiddleware,
+    OciMiddleware,
+    S3Middleware,
+)
+from rattler.rattler import PyClientWithMiddleware
+
+
+class Client:
+    """
+    A client that can be used to make requests.
+    """
+
+    def __init__(
+        self,
+        middlewares: (
+            list[
+                AddHeadersMiddleware
+                | AuthenticationMiddleware
+                | MirrorMiddleware
+                | OciMiddleware
+                | GCSMiddleware
+                | S3Middleware
+            ]
+            | None
+        ) = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        self._client = PyClientWithMiddleware(
+            [middleware._middleware for middleware in middlewares] if middlewares else None, headers
+        )
+
+    @classmethod
+    def _from_ffi_object(cls, client: PyClientWithMiddleware) -> Client:
+        """
+        Construct py-rattler Client from PyClientWithMiddleware FFI object.
+        """
+        client = cls.__new__(cls)
+        client._client = client
+        return client
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the Client
+
+        Examples
+        --------
+        ```python
+        >>> Client()
+        Client()
+        >>>
+        ```
+        """
+        return f"{type(self).__name__}()"
+
+    @staticmethod
+    def authenticated_client() -> Client:
+        """
+        Returns an authenticated client.
+
+        Examples
+        --------
+        ```python
+        >>> Client.authenticated_client()
+        Client()
+        >>>
+        ```
+        """
+        return Client([AuthenticationMiddleware()])

rattler/networking/fetch_repo_data.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Callable, List, Literal, Optional, Union, TYPE_CHECKING
+
+from rattler.networking.client import Client
+from rattler.rattler import py_fetch_repo_data, PyFetchRepoDataOptions
+from rattler.repo_data.sparse import SparseRepoData
+
+if TYPE_CHECKING:
+    import os
+    from rattler.channel import Channel
+    from rattler.platform import Platform
+
+
+CacheAction = Literal["cache-or-fetch", "use-cache-only", "force-cache-only", "no-cache"]
+Variant = Literal["after-patches", "from-packages", "current"]
+
+
+@dataclass
+class FetchRepoDataOptions:
+    cache_action: CacheAction = "cache-or-fetch"
+    """How to interact with the cache.
+
+    * `'cache-or-fetch'` (default): Use the cache if its up to date or fetch from the URL if there is no valid cached value.
+    * `'use-cache-only'`: Only use the cache, but error out if the cache is not up to date
+    * `'force-cache-only'`: Only use the cache, ignore whether or not it is up to date.
+    * `'no-cache'`: Do not use the cache even if there is an up to date entry
+    """
+
+    variant: Variant = "after-patches"
+    """Which type of repodata to download
+
+    * `'after-patches'` (default): Fetch the `repodata.json` file. This `repodata.json` has repodata patches applied.
+    * `'from-packages'` Fetch the `repodata_from_packages.json` file
+    * `'current'`: Fetch `current_repodata.json` file. This file contains only the latest version of each package.
+    """
+
+    jlap_enabled: bool = True
+    """Whether the JLAP compression is enabled or not."""
+
+    zstd_enabled: bool = True
+    """Whether the ZSTD compression is enabled or not."""
+
+    bz2_enabled: bool = True
+    """Whether the BZ2 compression is enabled or not."""
+
+    def _into_py(self) -> PyFetchRepoDataOptions:
+        """
+        Converts this object into a type that can be used by the Rust code.
+
+        Examples
+        --------
+        ```python
+        >>> FetchRepoDataOptions()._into_py() # doctest: +ELLIPSIS
+        <builtins.PyFetchRepoDataOptions object at 0x...>
+        >>>
+        ```
+        """
+        return PyFetchRepoDataOptions(
+            cache_action=self.cache_action,
+            variant=self.variant,
+            jlap_enabled=self.jlap_enabled,
+            zstd_enabled=self.zstd_enabled,
+            bz2_enabled=self.bz2_enabled,
+        )
+
+
+async def fetch_repo_data(
+    *,
+    channels: List[Channel],
+    platforms: List[Platform],
+    cache_path: Union[str, os.PathLike[str]],
+    callback: Optional[Callable[[int, int], None]],
+    client: Optional[Client] = None,
+    fetch_options: Optional[FetchRepoDataOptions] = None,
+) -> List[SparseRepoData]:
+    """
+    Returns a list of RepoData for given channels and platform.
+
+    Arguments:
+        channels: A list of `Channel`s to fetch repo data.
+        platforms: A list of `Platform`s for which the repo data
+                   should be fetched.
+        cache_path: A `os.PathLike[str]` where the repo data should
+                    be downloaded.
+        callback: A `Callable[[int, int], None]` to report the download
+                  progress of repo data.
+        client: A `Client` to use for fetching the repo data.
+
+    Returns:
+        A list of `SparseRepoData` for requested channels and platforms.
+    """
+    fetch_options = fetch_options or FetchRepoDataOptions()
+    repo_data_list = await py_fetch_repo_data(
+        [channel._channel for channel in channels],
+        [platform._inner for platform in platforms],
+        cache_path,
+        callback,
+        client._client if client else None,
+        fetch_options._into_py(),
+    )
+
+    return [SparseRepoData._from_py_sparse_repo_data(repo_data) for repo_data in repo_data_list]