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

rattler/package/run_exports_json.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+import os
+from pathlib import Path
+from typing import List
+
+from rattler.rattler import PyRunExportsJson
+
+
+class RunExportsJson:
+    """
+    A representation of the `run_exports.json` file found in package archives.
+    The `run_exports.json` file contains information about the run exports of a package
+    """
+
+    _inner: PyRunExportsJson
+
+    def __init__(
+        self,
+        weak: List[str] | None = None,
+        strong: List[str] | None = None,
+        noarch: List[str] | None = None,
+        weak_constrains: List[str] | None = None,
+        strong_constrains: List[str] | None = None,
+    ) -> None:
+        """
+        Create a new RunExportsJson instance.
+
+        Parameters
+        ----------
+        weak : List[str] | None, optional
+            Weak run exports apply a dependency from host to run
+        strong : List[str] | None, optional
+            Strong run exports apply a dependency from build to host and run
+        noarch : List[str] | None, optional
+            Noarch run exports apply a run export only to noarch packages
+        weak_constrains : List[str] | None, optional
+            Weak constrains apply a constrain dependency from host to build, or run to host
+        strong_constrains : List[str] | None, optional
+            Strong constrains apply a constrain dependency from build to host and run
+
+        Examples
+        --------
+        ```python
+        >>> run_exports = RunExportsJson(
+        ...     weak=["weak_dep 1.0"],
+        ...     strong=["strong_dep 2.0"],
+        ...     noarch=["noarch_dep 3.0"],
+        ...     weak_constrains=["weak_constrain 4.0"],
+        ...     strong_constrains=["strong_constrain 5.0"]
+        ... )
+        >>> run_exports
+        RunExportsJson(weak=['weak_dep 1.0'], strong=['strong_dep 2.0'], noarch=['noarch_dep 3.0'], weak_constrains=['weak_constrain 4.0'], strong_constrains=['strong_constrain 5.0'])
+        >>>
+        ```
+        """
+        self._inner = PyRunExportsJson(
+            weak or [], strong or [], noarch or [], weak_constrains or [], strong_constrains or []
+        )
+
+    @staticmethod
+    def from_package_archive(path: os.PathLike[str]) -> RunExportsJson:
+        """
+        Parses the package file from archive.
+        Note: If you want to extract multiple `info/*` files then this will be slightly
+              slower than manually iterating over the archive entries with
+              custom logic as this skips over the rest of the archive
+        """
+        return RunExportsJson._from_py_run_exports_json(PyRunExportsJson.from_package_archive(path))
+
+    @staticmethod
+    def from_path(path: os.PathLike[str]) -> RunExportsJson:
+        """
+        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 JSON format, this function reads the data
+        from the file at the specified path, parse the JSON string and return the
+        resulting object. If the file is not in a parsable format or if the file
+        could not read, this function returns an error.
+
+        Examples
+        --------
+        ```python
+        >>> run_exports = RunExportsJson.from_path(
+        ...     "../test-data/python-3.10.6-h2c4edbf_0_cpython-run_exports.json"
+        ... )
+        >>> run_exports
+        RunExportsJson(weak=['python_abi 3.10.* *_cp310'], strong=[], noarch=['python'], weak_constrains=[], strong_constrains=[])
+        >>>
+        ```
+        """
+        return RunExportsJson._from_py_run_exports_json(PyRunExportsJson.from_path(Path(path)))
+
+    @staticmethod
+    def from_package_directory(path: os.PathLike[str]) -> RunExportsJson:
+        """
+        Parses the object by looking up the appropriate file from the root of the
+        specified Conda archive directory, using a format appropriate for the file
+        type.
+
+        For example, if the file is in JSON format, this function reads the
+        appropriate file from the archive, parse the JSON string and return the
+        resulting object. If the file is not in a parsable format or if the file
+        could not be read, this function returns an error.
+        """
+        return RunExportsJson._from_py_run_exports_json(PyRunExportsJson.from_package_directory(Path(path)))
+
+    @staticmethod
+    def from_str(string: str) -> RunExportsJson:
+        """
+        Parses the object from a string, using a format appropriate for the file
+        type.
+
+        For example, if the file is in JSON format, this function parses the JSON
+        string and returns the resulting object. If the file is not in a parsable
+        format, this function returns an error.
+        """
+        return RunExportsJson._from_py_run_exports_json(PyRunExportsJson.from_str(string))
+
+    @staticmethod
+    def package_path() -> Path:
+        """
+        Returns the path to the file within the Conda archive.
+
+        The path is relative to the root of the archive and includes any necessary
+        directories.
+        """
+        return PyRunExportsJson.package_path()
+
+    @property
+    def weak(self) -> List[str]:
+        """
+        Weak run exports apply a dependency from host to run.
+
+        Examples
+        --------
+        ```python
+        >>> run_exports = RunExportsJson.from_path(
+        ...     "../test-data/python-3.10.6-h2c4edbf_0_cpython-run_exports.json"
+        ... )
+        >>> run_exports.weak
+        ['python_abi 3.10.* *_cp310']
+        >>> run_exports.weak = ['new_dep 1.0']
+        >>> run_exports.weak
+        ['new_dep 1.0']
+        >>>
+        ```
+        """
+        return self._inner.weak
+
+    @weak.setter
+    def weak(self, value: List[str]) -> None:
+        self._inner.weak = value
+
+    @property
+    def strong(self) -> List[str]:
+        """
+        Strong run exports apply a dependency from build to host and run.
+
+        Examples
+        --------
+        ```python
+        >>> run_exports = RunExportsJson.from_path(
+        ...     "../test-data/python-3.10.6-h2c4edbf_0_cpython-run_exports.json"
+        ... )
+        >>> run_exports.strong
+        []
+        >>> run_exports.strong = ['strong_dep 2.0']
+        >>> run_exports.strong
+        ['strong_dep 2.0']
+        >>>
+        ```
+        """
+        return self._inner.strong
+
+    @strong.setter
+    def strong(self, value: List[str]) -> None:
+        self._inner.strong = value
+
+    @property
+    def noarch(self) -> List[str]:
+        """
+        NoArch run exports apply a run export only to noarch packages (other run exports are ignored).
+        For example, python uses this to apply a dependency on python to all noarch packages, but not to
+        the python_abi package.
+
+        Examples
+        --------
+        ```python
+        >>> run_exports = RunExportsJson.from_path(
+        ...     "../test-data/python-3.10.6-h2c4edbf_0_cpython-run_exports.json"
+        ... )
+        >>> run_exports.noarch
+        ['python']
+        >>> run_exports.noarch = ['noarch_dep 3.0']
+        >>> run_exports.noarch
+        ['noarch_dep 3.0']
+        >>>
+        ```
+        """
+        return self._inner.noarch
+
+    @noarch.setter
+    def noarch(self, value: List[str]) -> None:
+        self._inner.noarch = value
+
+    @property
+    def weak_constrains(self) -> List[str]:
+        """
+        Weak constrains apply a constrain dependency from host to build, or run to host.
+
+        Examples
+        --------
+        ```python
+        >>> run_exports = RunExportsJson.from_path(
+        ...     "../test-data/python-3.10.6-h2c4edbf_0_cpython-run_exports.json"
+        ... )
+        >>> run_exports.weak_constrains
+        []
+        >>> run_exports.weak_constrains = ['weak_constrain 4.0']
+        >>> run_exports.weak_constrains
+        ['weak_constrain 4.0']
+        >>>
+        ```
+        """
+        return self._inner.weak_constrains
+
+    @weak_constrains.setter
+    def weak_constrains(self, value: List[str]) -> None:
+        self._inner.weak_constrains = value
+
+    @property
+    def strong_constrains(self) -> List[str]:
+        """
+        Strong constrains apply a constrain dependency from build to host and run.
+
+        Examples
+        --------
+        ```python
+        >>> run_exports = RunExportsJson.from_path(
+        ...     "../test-data/python-3.10.6-h2c4edbf_0_cpython-run_exports.json"
+        ... )
+        >>> run_exports.strong_constrains
+        []
+        >>> run_exports.strong_constrains = ['strong_constrain 5.0']
+        >>> run_exports.strong_constrains
+        ['strong_constrain 5.0']
+        >>>
+        ```
+        """
+        return self._inner.strong_constrains
+
+    @strong_constrains.setter
+    def strong_constrains(self, value: List[str]) -> None:
+        self._inner.strong_constrains = value
+
+    @classmethod
+    def _from_py_run_exports_json(cls, py_run_exports_json: PyRunExportsJson) -> RunExportsJson:
+        run_exports_json = cls.__new__(cls)
+        run_exports_json._inner = py_run_exports_json
+
+        return run_exports_json
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the RunExportsJson.
+        """
+        return f"RunExportsJson(weak={self.weak}, strong={self.strong}, noarch={self.noarch}, weak_constrains={self.weak_constrains}, strong_constrains={self.strong_constrains})"

rattler/package_streaming/__init__.py

@@ -0,0 +1,26 @@
+from typing import Tuple, Optional
+from os import PathLike
+from rattler.networking.client import Client
+
+from rattler.rattler import (
+    extract as py_extract,
+    extract_tar_bz2 as py_extract_tar_bz2,
+    download_and_extract as py_download_and_extract,
+)
+
+
+def extract(path: PathLike[str], dest: PathLike[str]) -> Tuple[bytes, bytes]:
+    """Extract a file to a destination."""
+    return py_extract(path, dest)
+
+
+def extract_tar_bz2(path: PathLike[str], dest: PathLike[str]) -> Tuple[bytes, bytes]:
+    """Extract a tar.bz2 file to a destination."""
+    return py_extract_tar_bz2(path, dest)
+
+
+async def download_and_extract(
+    client: Client, url: str, dest: PathLike[str], expected_sha: Optional[bytes] = None
+) -> Tuple[bytes, bytes]:
+    """Download a file from a URL and extract it to a destination."""
+    return await py_download_and_extract(client._client, url, dest, expected_sha)

rattler/platform/__init__.py

@@ -0,0 +1,4 @@
+from rattler.platform.platform import Platform, PlatformLiteral
+from rattler.platform.arch import Arch
+
+__all__ = ["Platform", "PlatformLiteral", "Arch"]

rattler/platform/arch.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from rattler.rattler import PyArch
+
+from typing import Literal
+
+ArchLiteral = Literal[
+    "x86",
+    "x86_64",
+    "aarch64",
+    "armv6l",
+    "armv7l",
+    "loongarch64",
+    "ppc64le",
+    "ppc64",
+    "s390x",
+    "riscv32",
+    "riscv64",
+]
+
+
+class Arch:
+    def __init__(self, value: ArchLiteral) -> None:
+        self._inner = PyArch(value)
+
+    @classmethod
+    def _from_py_arch(cls, py_arch: PyArch) -> Arch:
+        """Construct Rattler version from FFI PyArch object."""
+        arch = cls.__new__(cls)
+        arch._inner = py_arch
+        return arch
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the architecture.
+
+        Examples
+        --------
+        ```python
+        >>> str(Arch("x86_64"))
+        'x86_64'
+        >>>
+        ```
+        """
+        return self._inner.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the architecture.
+
+        Examples
+        --------
+        ```python
+        >>> Arch("aarch64")
+        Arch(aarch64)
+        >>>
+        ```
+        """
+        return f"Arch({self._inner.as_str()})"

rattler/platform/platform.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+from collections.abc import Iterator
+from typing import Any, Dict, Literal, Tuple, Optional
+
+from rattler.rattler import PyPlatform
+from rattler.platform.arch import Arch
+
+PlatformLiteral = Literal[
+    "noarch",
+    "unknown",
+    "linux-32",
+    "linux-64",
+    "linux-aarch64",
+    "linux-armv6l",
+    "linux-armv7l",
+    "linux-loongarch64",
+    "linux-ppc64le",
+    "linux-ppc64",
+    "linux-ppc",
+    "linux-s390x",
+    "linux-riscv32",
+    "linux-riscv64",
+    "freebsd-64",
+    "osx-64",
+    "osx-arm64",
+    "win-32",
+    "win-64",
+    "win-arm64",
+    "emscripten-wasm32",
+    "wasi-wasm32",
+    "zos-z",
+]
+
+
+class PlatformSingleton(type):
+    _instances: Dict[str, Platform]
+
+    def __init__(cls, *args: Tuple[Any], **kwargs: Dict[Any, Any]) -> None:
+        cls._instances = {}
+
+    def __call__(cls, platform: str, *args: Tuple[Any], **kwargs: Dict[Any, Any]) -> Platform:
+        try:
+            return cls._instances[platform]
+        except KeyError:
+            pass
+
+        instance = super().__call__(platform, *args, **kwargs)
+        cls._instances[platform] = instance
+        return instance
+
+
+class Platform(metaclass=PlatformSingleton):
+    def __init__(self, value: PlatformLiteral | str):
+        self._inner = PyPlatform(value)
+
+    @classmethod
+    def _from_py_platform(cls, py_platform: PyPlatform) -> Platform:
+        """Construct Rattler version from FFI PyArch object."""
+        try:
+            platform = cls._instances[py_platform.name]
+        except KeyError:
+            platform = cls.__new__(cls)
+            platform._inner = py_platform
+            cls._instances[str(platform)] = platform
+        return platform
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the platform.
+
+        Examples
+        --------
+        ```python
+        >>> str(Platform("linux-64"))
+        'linux-64'
+        >>>
+        ```
+        """
+        return self._inner.name
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the platform.
+
+        Examples
+        --------
+        ```python
+        >>> Platform("linux-64")
+        Platform(linux-64)
+        >>>
+        ```
+        """
+        return f"Platform({self._inner.name})"
+
+    @classmethod
+    def current(cls) -> Platform:
+        """
+        Returns the current platform.
+        """
+        return cls._from_py_platform(PyPlatform.current())
+
+    @classmethod
+    def all(cls) -> Iterator[Platform]:
+        """
+        Returns all supported platforms.
+
+        Examples
+        --------
+        ```python
+        >>> next(Platform.all())
+        Platform(noarch)
+        >>> len(list(Platform.all()))
+        23
+        >>>
+        """
+        return (cls._from_py_platform(p) for p in PyPlatform.all())
+
+    @property
+    def is_linux(self) -> bool:
+        """
+        Return True if the platform is linux.
+
+        Examples
+        --------
+        ```python
+        >>> Platform("linux-64").is_linux
+        True
+        >>> Platform("osx-64").is_linux
+        False
+        >>>
+        ```
+        """
+        return self._inner.is_linux
+
+    @property
+    def is_osx(self) -> bool:
+        """
+        Return True if the platform is osx.
+
+        Examples
+        --------
+        ```python
+        >>> Platform("osx-64").is_osx
+        True
+        >>> Platform("linux-64").is_osx
+        False
+        >>>
+        ```
+        """
+        return self._inner.is_osx
+
+    @property
+    def is_windows(self) -> bool:
+        """
+        Return True if the platform is win.
+
+        Examples
+        --------
+        ```python
+        >>> Platform("win-64").is_windows
+        True
+        >>> Platform("linux-64").is_windows
+        False
+        >>>
+        ```
+        """
+        return self._inner.is_windows
+
+    @property
+    def is_unix(self) -> bool:
+        """
+        Return True if the platform is unix.
+
+        Examples
+        --------
+        ```python
+        >>> Platform("linux-64").is_unix
+        True
+        >>> Platform("win-64").is_unix
+        False
+        >>>
+        ```
+        """
+        return self._inner.is_unix
+
+    @property
+    def arch(self) -> Optional[Arch]:
+        """
+        Return the architecture of the platform.
+
+        Examples
+        --------
+        ```python
+        >>> Platform("linux-64").arch
+        Arch(x86_64)
+        >>> Platform("linux-aarch64").arch
+        Arch(aarch64)
+        >>>
+        ```
+        """
+        arch = self._inner.arch()
+        return Arch._from_py_arch(arch) if arch is not None else None
+
+    @property
+    def only_platform(self) -> Optional[str]:
+        """
+        Return the platform without the architecture.
+
+        Examples
+        --------
+        ```python
+        >>> Platform("linux-64").only_platform
+        'linux'
+        >>>
+        ```
+        """
+        return self._inner.only_platform

rattler/prefix/__init__.py

@@ -0,0 +1,4 @@
+from rattler.prefix.prefix_record import PrefixRecord, Link, LinkType
+from rattler.prefix.prefix_paths import PrefixPaths, PrefixPathsEntry, PrefixPathType
+
+__all__ = ["PrefixRecord", "PrefixPaths", "PrefixPathsEntry", "PrefixPathType", "Link", "LinkType"]