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

rattler/version/version_spec.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rattler.rattler import PyVersionSpec
+
+if TYPE_CHECKING:
+    from rattler.version.version import Version
+
+
+class VersionSpec:
+    """
+    A version specification represents a constraint on a version.
+
+    Version specifications can be simple like ">=1.2.3" or complex
+    with multiple constraints like ">=1.2.3,<2.0.0" or ">=1.2.3|<1.0.0".
+
+    Examples
+    --------
+    ```python
+    >>> from rattler import VersionSpec, Version
+    >>> spec = VersionSpec(">=1.2.3,<2.0.0")
+    >>> version = Version("1.5.0")
+    >>> spec.matches(version)
+    True
+    >>> version2 = Version("2.1.0")
+    >>> spec.matches(version2)
+    False
+    >>>
+    ```
+    """
+
+    _spec: PyVersionSpec
+
+    def __init__(self, spec: str, strict: bool = False) -> None:
+        """
+        Construct a new VersionSpec from a string.
+
+        Parameters
+        ----------
+        spec : str
+            The version specification string (e.g., ">=1.2.3,<2.0.0")
+        strict : bool, optional
+            If True, use strict parsing mode (default: False)
+
+        Raises
+        ------
+        InvalidVersionSpecError
+            If the version specification string is invalid
+
+        Examples
+        --------
+        ```python
+        >>> spec = VersionSpec(">=1.2.3,<2.0.0")
+        >>> spec_strict = VersionSpec(">=1.2.3", strict=True)
+        >>> spec_any = VersionSpec("*")
+        >>>
+        ```
+        """
+        if isinstance(spec, str):
+            self._spec = PyVersionSpec(spec, strict)
+        else:
+            raise TypeError(
+                f"VersionSpec constructor received unsupported type {type(spec).__name__!r} for the `spec` parameter"
+            )
+
+    @classmethod
+    def _from_py_version_spec(cls, py_spec: PyVersionSpec) -> VersionSpec:
+        """Construct Rattler VersionSpec from FFI PyVersionSpec object."""
+        spec = cls.__new__(cls)
+        spec._spec = py_spec
+        return spec
+
+    def matches(self, version: Version) -> bool:
+        """
+        Check if a version matches this version specification.
+
+        Parameters
+        ----------
+        version : Version
+            The version to check
+
+        Returns
+        -------
+        bool
+            True if the version matches the specification, False otherwise
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import VersionSpec, Version
+        >>> spec = VersionSpec(">=1.2.3,<2.0.0")
+        >>> spec.matches(Version("1.5.0"))
+        True
+        >>> spec.matches(Version("2.1.0"))
+        False
+        >>> spec.matches(Version("1.2.3"))
+        True
+        >>> spec.matches(Version("2.0.0"))
+        False
+        >>>
+        ```
+        """
+        return self._spec.matches(version._version)
+
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the version specification.
+
+        Examples
+        --------
+        ```python
+        >>> str(VersionSpec(">=1.2.3,<2.0.0"))
+        '>=1.2.3,<2.0.0'
+        >>>
+        ```
+        """
+        return self._spec.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the version specification.
+
+        Examples
+        --------
+        ```python
+        >>> VersionSpec(">=1.2.3,<2.0.0")
+        VersionSpec(">=1.2.3,<2.0.0")
+        >>>
+        ```
+        """
+        return f'VersionSpec("{self._spec.as_str()}")'
+
+    def __hash__(self) -> int:
+        """
+        Computes the hash of this instance.
+
+        Examples
+        --------
+        ```python
+        >>> hash(VersionSpec(">=1.2.3")) == hash(VersionSpec(">=1.2.3"))
+        True
+        >>> hash(VersionSpec(">=1.2.3")) == hash(VersionSpec(">=2.0.0"))
+        False
+        >>>
+        ```
+        """
+        return self._spec.__hash__()
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Returns True if this instance represents the same version spec as `other`.
+
+        Examples
+        --------
+        ```python
+        >>> VersionSpec(">=1.2.3") == VersionSpec(">=1.2.3")
+        True
+        >>> VersionSpec(">=1.2.3") == VersionSpec(">=2.0.0")
+        False
+        >>>
+        ```
+        """
+        if not isinstance(other, VersionSpec):
+            return NotImplemented
+        return self._spec == other._spec
+
+    def __ne__(self, other: object) -> bool:
+        """
+        Returns False if this instance represents the same version spec as `other`.
+
+        Examples
+        --------
+        ```python
+        >>> VersionSpec(">=1.2.3") != VersionSpec(">=1.2.3")
+        False
+        >>> VersionSpec(">=1.2.3") != VersionSpec(">=2.0.0")
+        True
+        >>>
+        ```
+        """
+        if not isinstance(other, VersionSpec):
+            return NotImplemented
+        return self._spec != other._spec

rattler/version/with_source.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Union, Optional
+
+from rattler.rattler import PyVersion
+
+from rattler.version import Version
+
+
+class VersionWithSource(Version):
+    """
+    Holds a version and the string it was created from. This is useful if
+    you want to retain the original string the version was created from.
+    This might be useful in cases where you have multiple strings that
+    are represented by the same [`Version`] but you still want to be able to
+    distinguish them.
+
+    The string `1.1` and `1.01` represent the same version. When you print
+    the parsed version though it will come out as `1.1`. You loose the
+    original representation. This class stores the original source string,
+    which can be accessed by `source` property.
+
+    This class derives from `Version` which allows you to compare it with
+    other `Version` objects.
+
+    Comparison will be done based on the parsed version, not the source string.
+    """
+
+    _source: str
+
+    def __init__(self, version: Union[str, Version]):
+        if not isinstance(version, (str, Version)):
+            raise TypeError(
+                "VersionWithSource constructor received unsupported type "
+                f" {type(version).__name__!r} for the `version` parameter"
+            )
+
+        if isinstance(version, str):
+            self._source = version
+            self._version = PyVersion(version)
+
+        if isinstance(version, Version):
+            self._source = str(version)
+            self._version = version._version
+
+    @classmethod
+    def _from_py_version(cls, py_version: PyVersion, source: Optional[str] = None) -> VersionWithSource:
+        """Construct Rattler version from FFI PyVersion object."""
+        version = cls.__new__(cls)
+        version._version = py_version
+        version._source = source or py_version.as_str()
+        return version
+
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the version
+
+        Examples
+        --------
+        ```python
+        >>> str(VersionWithSource("1.02.3"))
+        '1.02.3'
+        >>>
+        ```
+        """
+        return self._source
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the version
+
+        Examples
+        --------
+        ```python
+        >>> VersionWithSource("1.02.3")
+        VersionWithSource(version="1.2.3", source="1.02.3")
+        >>>
+        ```
+        """
+        return f'{type(self).__name__}(version="{self._version.as_str()}", source="{self._source}")'

rattler/virtual_package/__init__.py

@@ -0,0 +1,4 @@
+from rattler.virtual_package.generic import GenericVirtualPackage
+from rattler.virtual_package.virtual_package import VirtualPackage, VirtualPackageOverrides, Override
+
+__all__ = ["GenericVirtualPackage", "VirtualPackage", "VirtualPackageOverrides", "Override"]

rattler/virtual_package/generic.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from rattler.version import Version
+from rattler.package import PackageName
+
+from rattler.rattler import PyGenericVirtualPackage
+
+
+class GenericVirtualPackage:
+    _generic_virtual_package: PyGenericVirtualPackage
+
+    def __init__(self, name: PackageName, version: Version, build_string: str) -> None:
+        if not isinstance(name, PackageName):
+            raise TypeError(
+                "GenericVirtualPackage constructor received unsupported type "
+                f" {type(name).__name__!r} for the `name` parameter"
+            )
+
+        if not isinstance(version, Version):
+            raise TypeError(
+                "GenericVirtualPackage constructor received unsupported type "
+                f" {type(version).__name__!r} for the `version` parameter"
+            )
+
+        if not isinstance(build_string, str):
+            raise TypeError(
+                "GenericVirtualPackage constructor received unsupported type "
+                f" {type(build_string).__name__!r} for the `build_string` parameter"
+            )
+
+        self._generic_virtual_package = PyGenericVirtualPackage(name._name, version._version, build_string)
+
+    @property
+    def name(self) -> PackageName:
+        """
+        Returns the name of the package
+
+        Examples
+        --------
+        ```python
+        >>> from rattler.package.package_name import PackageName
+        >>> from rattler.version.version import Version
+        >>> gvp = GenericVirtualPackage(PackageName("__archspec"), Version("1"), "x86_64")
+        >>> gvp.name
+        PackageName("__archspec")
+        >>> gvp.name.source
+        '__archspec'
+        >>> gvp.name.normalized
+        '__archspec'
+        >>>
+        ```
+        """
+        return PackageName._from_py_package_name(self._generic_virtual_package.name)
+
+    @property
+    def version(self) -> Version:
+        """
+        Returns the version of the package
+
+        Examples
+        --------
+        ```python
+        >>> from rattler.package.package_name import PackageName
+        >>> from rattler.version.version import Version
+        >>> gvp = GenericVirtualPackage(PackageName("__archspec"), Version("1"), "x86_64")
+        >>> gvp.version
+        Version("1")
+        >>>
+        ```
+        """
+        return Version._from_py_version(self._generic_virtual_package.version)
+
+    @property
+    def build_string(self) -> str:
+        """
+        Returns the build identifier of the package.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler.package.package_name import PackageName
+        >>> from rattler.version.version import Version
+        >>> gvp = GenericVirtualPackage(PackageName("__archspec"), Version("1"), "x86_64")
+        >>> gvp.build_string
+        'x86_64'
+        >>>
+        ```
+        """
+        return self._generic_virtual_package.build_string
+
+    @classmethod
+    def _from_py_generic_virtual_package(
+        cls, py_generic_virtual_package: PyGenericVirtualPackage
+    ) -> GenericVirtualPackage:
+        """
+        Construct Rattler GenericVirtualPackage from FFI
+        PyGenericVirtualPackage object.
+        """
+        generic_virtual_package = cls.__new__(cls)
+        generic_virtual_package._generic_virtual_package = py_generic_virtual_package
+        return generic_virtual_package
+
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the GenericVirtualPackage
+
+        Examples
+        --------
+        ```python
+        >>> from rattler.package.package_name import PackageName
+        >>> from rattler.version.version import Version
+        >>> gvp = GenericVirtualPackage(PackageName("__archspec"), Version("1"), "x86_64")
+        >>> str(gvp)
+        '__archspec=1=x86_64'
+        >>>
+        ```
+        """
+
+        return self._generic_virtual_package.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the GenericVirtualPackage
+
+        Examples
+        --------
+        ```python
+        >>> from rattler.package.package_name import PackageName
+        >>> from rattler.version.version import Version
+        >>> gvp = GenericVirtualPackage(PackageName("__archspec"), Version("1"), "x86_64")
+        >>> gvp
+        GenericVirtualPackage("__archspec=1=x86_64")
+        >>>
+        ```
+        """
+        return f'GenericVirtualPackage("{self._generic_virtual_package.as_str()}")'

rattler/virtual_package/virtual_package.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+from typing import List
+import warnings
+
+from rattler.rattler import PyVirtualPackage, PyOverride, PyVirtualPackageOverrides
+
+from rattler.virtual_package.generic import GenericVirtualPackage
+
+
+class Override:
+    """
+    Represents an override for a virtual package.
+    An override can be build using
+    - `Override.default_env_var()` for overriding the detection with the default environment variable,
+    - `Override.env_var(str)` for overriding the detection with a custom environment variable,
+    - `Override.string(str)` for passing the version directly, or
+    """
+
+    _override: PyOverride
+
+    @classmethod
+    def _from_py_override(cls, py_override: PyOverride) -> Override:
+        """Construct Rattler Override from FFI PyOverride object."""
+        override = cls.__new__(cls)
+        override._override = py_override
+        return override
+
+    @classmethod
+    def default_env_var(cls) -> Override:
+        """
+        Returns a new instance to indicate that the default environment variable should overwrite the detected information from the host if specified.
+        """
+        return cls._from_py_override(PyOverride.default_env_var())
+
+    @classmethod
+    def env_var(cls, env_var: str) -> Override:
+        """
+        Returns the environment variable override for the given environment variable.
+        """
+        return cls._from_py_override(PyOverride.env_var(env_var))
+
+    @classmethod
+    def string(cls, override: str) -> Override:
+        """
+        Returns the override for the given string.
+        """
+        return cls._from_py_override(PyOverride.string(override))
+
+    def __str__(self) -> str:
+        """
+        Returns string representation of the Override.
+        """
+        return self._override.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the Override.
+        """
+        return f"Override({self._override.as_str()})"
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Returns True if the Overrides are equal, False otherwise.
+        """
+        if not isinstance(other, Override):
+            return NotImplemented
+        return self._override == other._override
+
+
+class VirtualPackageOverrides:
+    _overrides: PyVirtualPackageOverrides
+
+    @classmethod
+    def _from_py_virtual_package_overrides(
+        cls, py_virtual_package_overrides: PyVirtualPackageOverrides
+    ) -> VirtualPackageOverrides:
+        """Construct Rattler VirtualPackageOverrides from FFI PyVirtualPackageOverrides object."""
+        virtual_package_overrides = cls.__new__(cls)
+        virtual_package_overrides._overrides = py_virtual_package_overrides
+        return virtual_package_overrides
+
+    def __init__(self, osx: Override | None = None, libc: Override | None = None, cuda: Override | None = None) -> None:
+        """
+        Returns the default virtual package overrides. By default, none of the overrides are set.
+        """
+        self._overrides = PyVirtualPackageOverrides.none()
+        self.osx = osx
+        self.libc = libc
+        self.cuda = cuda
+
+    @classmethod
+    def from_env(cls) -> VirtualPackageOverrides:
+        """
+        Returns the virtual package overrides for None.
+        """
+        return cls._from_py_virtual_package_overrides(PyVirtualPackageOverrides.from_env())
+
+    @property
+    def osx(self) -> Override | None:
+        """
+        Returns the OSX override.
+        """
+        override = self._overrides.osx
+        return Override._from_py_override(override) if override else None
+
+    @osx.setter
+    def osx(self, override: Override | None) -> None:
+        """
+        Sets the OSX override.
+        """
+        self._overrides.osx = override._override if override else None
+
+    @property
+    def libc(self) -> Override | None:
+        """
+        Returns the libc override.
+        """
+        override = self._overrides.libc
+        return Override._from_py_override(override) if override else None
+
+    @libc.setter
+    def libc(self, override: Override | None) -> None:
+        """
+        Sets the libc override.
+        """
+        self._overrides.libc = override._override if override else None
+
+    @property
+    def cuda(self) -> Override | None:
+        """
+        Returns the CUDA override.
+        """
+        override = self._overrides.cuda
+        return Override._from_py_override(override) if override else None
+
+    @cuda.setter
+    def cuda(self, override: Override | None) -> None:
+        """
+        Sets the CUDA override.
+        """
+        self._overrides.cuda = override._override if override else None
+
+    def __str__(self) -> str:
+        """
+        Returns string representation of the VirtualPackageOverrides.
+        """
+        return self._overrides.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the VirtualPackageOverrides.
+        """
+        return f"VirtualPackageOverrides({self._overrides.as_str()})"
+
+
+class VirtualPackage:
+    _virtual_package: PyVirtualPackage
+
+    @classmethod
+    def _from_py_virtual_package(cls, py_virtual_package: PyVirtualPackage) -> VirtualPackage:
+        """Construct Rattler VirtualPackage from FFI PyVirtualPackage object."""
+        virtual_package = cls.__new__(cls)
+        virtual_package._virtual_package = py_virtual_package
+        return virtual_package
+
+    @staticmethod
+    def current() -> List[VirtualPackage]:
+        """
+        Returns virtual packages detected for the current system or an error
+        if the versions could not be properly detected.
+
+        .. deprecated:: 0.7.0 Use `detect` instead.
+        """
+        warnings.warn("Use `detect` instead")
+        return VirtualPackage.detect()
+
+    @staticmethod
+    def detect(overrides: VirtualPackageOverrides = VirtualPackageOverrides()) -> List[VirtualPackage]:
+        """
+        Returns virtual packages detected for the current system with the given overrides.
+        """
+        return [VirtualPackage._from_py_virtual_package(vp) for vp in PyVirtualPackage.detect(overrides._overrides)]
+
+    def into_generic(self) -> GenericVirtualPackage:
+        """
+        Returns a GenericVirtualPackage from VirtualPackage.
+        """
+        # subclass from Generic instead.
+        return GenericVirtualPackage._from_py_generic_virtual_package(self._virtual_package.as_generic())
+
+    def __str__(self) -> str:
+        """
+        Returns string representation of the VirtualPackage.
+        """
+        return self._virtual_package.as_str()
+
+    def __repr__(self) -> str:
+        """
+        Returns a representation of the VirtualPackage.
+        """
+        return f"VirtualPackage({self._virtual_package.as_str()})"