add channel types to py-rattler

py-rattler/Cargo.toml

@@ -18,6 +18,7 @@ pyo3 = { version = "0.19", features = [
 ] }
 
 thiserror = "1.0.44"
+url = "2.4.1"
 
 # Prevent package from thinking it's in the workspace
 [workspace]

py-rattler/rattler/__init__.py

@@ -1,5 +1,13 @@
 from rattler.version import Version
 from rattler.match_spec import MatchSpec, NamelessMatchSpec
 from rattler.repo_data import PackageRecord
+from rattler.channel import Channel, ChannelConfig
 
-__all__ = ["Version", "MatchSpec", "NamelessMatchSpec", "PackageRecord"]
+__all__ = [
+    "Version",
+    "MatchSpec",
+    "NamelessMatchSpec",
+    "PackageRecord",
+    "Channel",
+    "ChannelConfig",
+]

py-rattler/rattler/channel/__init__.py

@@ -0,0 +1,4 @@
+from rattler.channel.channel import Channel
+from rattler.channel.channel_config import ChannelConfig
+
+__all__ = ["Channel", "ChannelConfig"]

py-rattler/rattler/channel/channel.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+from typing import Optional
+
+from rattler.rattler import PyChannel
+from rattler.channel.channel_config import ChannelConfig
+
+
+class Channel:
+    def __init__(self, name: str, channel_configuration: ChannelConfig):
+        """
+        Create a new channel.
+
+        >>> channel = Channel("conda-forge", ChannelConfig())
+        >>> channel
+        Channel(name="conda-forge", base_url="https://conda.anaconda.org/conda-forge/")
+        """
+        self._channel = PyChannel(name, channel_configuration._channel_configuration)
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        Return the name of this channel.
+
+        >>> channel = Channel("conda-forge", ChannelConfig())
+        >>> channel.name
+        'conda-forge'
+        """
+        return self._channel.name
+
+    @property
+    def base_url(self) -> str:
+        """
+        Return the base URL of this channel.
+
+        >>> channel = Channel("conda-forge", ChannelConfig())
+        >>> channel.base_url
+        'https://conda.anaconda.org/conda-forge/'
+        """
+        return self._channel.base_url
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of this channel.
+        """
+        return f'Channel(name="{self.name}", base_url="{self.base_url}")'

py-rattler/rattler/channel/channel_config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from rattler.rattler import PyChannelConfig
+
+
+class ChannelConfig:
+    def __init__(self, channel_alias="https://conda.anaconda.org/"):
+        """
+        Create a new channel configuration.
+
+        >>> channel_config = ChannelConfig()
+        >>> channel_config
+        ChannelConfig(channel_alias="https://conda.anaconda.org/")
+
+        >>> channel_config = ChannelConfig("https://repo.prefix.dev/")
+        >>> channel_config
+        ChannelConfig(channel_alias="https://repo.prefix.dev/")
+        """
+        self._channel_configuration = PyChannelConfig(channel_alias)
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of this channel configuration.
+        """
+        alias = self._channel_configuration.channel_alias
+        return f'ChannelConfig(channel_alias="{alias}")'

py-rattler/src/channel/mod.rs

@@ -0,0 +1,71 @@
+use pyo3::{pyclass, pymethods};
+use rattler_conda_types::{Channel, ChannelConfig};
+use url::Url;
+
+use crate::error::PyRattlerError;
+
+#[pyclass]
+#[repr(transparent)]
+#[derive(Clone)]
+pub struct PyChannelConfig {
+    pub(crate) inner: ChannelConfig,
+}
+
+#[pymethods]
+impl PyChannelConfig {
+    #[new]
+    pub fn __init__(channel_alias: &str) -> pyo3::PyResult<Self> {
+        Ok(Self {
+            inner: ChannelConfig {
+                channel_alias: Url::parse(channel_alias).map_err(PyRattlerError::from)?,
+            },
+        })
+    }
+
+    /// Return the channel alias that is configured
+    #[getter]
+    fn channel_alias(&self) -> String {
+        self.inner.channel_alias.to_string()
+    }
+}
+
+#[pyclass]
+#[repr(transparent)]
+#[derive(Clone)]
+pub struct PyChannel {
+    pub(crate) inner: Channel,
+}
+
+impl From<Channel> for PyChannel {
+    fn from(value: Channel) -> Self {
+        Self { inner: value }
+    }
+}
+
+impl From<PyChannel> for Channel {
+    fn from(val: PyChannel) -> Self {
+        val.inner
+    }
+}
+
+#[pymethods]
+impl PyChannel {
+    #[new]
+    pub fn __init__(version: &str, config: &PyChannelConfig) -> pyo3::PyResult<Self> {
+        Ok(Channel::from_str(version, &config.inner)
+            .map(Into::into)
+            .map_err(PyRattlerError::from)?)
+    }
+
+    /// Return the name of the channel
+    #[getter]
+    fn name(&self) -> Option<String> {
+        self.inner.name.clone()
+    }
+
+    /// Return the base url of the channel
+    #[getter]
+    fn base_url(&self) -> String {
+        self.inner.base_url.to_string()
+    }
+}

py-rattler/src/error.rs

@@ -1,6 +1,8 @@
 use pyo3::exceptions::PyException;
 use pyo3::{create_exception, PyErr};
-use rattler_conda_types::{InvalidPackageNameError, ParseMatchSpecError, ParseVersionError};
+use rattler_conda_types::{
+    InvalidPackageNameError, ParseChannelError, ParseMatchSpecError, ParseVersionError,
+};
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -12,6 +14,10 @@ pub enum PyRattlerError {
     InvalidMatchSpec(#[from] ParseMatchSpecError),
     #[error(transparent)]
     InvalidPackageName(#[from] InvalidPackageNameError),
+    #[error(transparent)]
+    InvalidUrl(#[from] url::ParseError),
+    #[error(transparent)]
+    InvalidChannel(#[from] ParseChannelError),
 }
 
 impl From<PyRattlerError> for PyErr {
@@ -26,10 +32,16 @@ impl From<PyRattlerError> for PyErr {
             PyRattlerError::InvalidPackageName(err) => {
                 InvalidPackageNameException::new_err(err.to_string())
             }
+            PyRattlerError::InvalidUrl(err) => InvalidUrlException::new_err(err.to_string()),
+            PyRattlerError::InvalidChannel(err) => {
+                InvalidChannelException::new_err(err.to_string())
+            }
         }
     }
 }
 
 create_exception!(exceptions, InvalidVersionException, PyException);
 create_exception!(exceptions, InvalidMatchSpecException, PyException);
 create_exception!(exceptions, InvalidPackageNameException, PyException);
+create_exception!(exceptions, InvalidUrlException, PyException);
+create_exception!(exceptions, InvalidChannelException, PyException);

py-rattler/src/lib.rs

@@ -1,11 +1,14 @@
+mod channel;
 mod error;
 mod match_spec;
 mod nameless_match_spec;
 mod repo_data;
 mod version;
 
+use channel::{PyChannel, PyChannelConfig};
 use error::{
-    InvalidMatchSpecException, InvalidPackageNameException, InvalidVersionException, PyRattlerError,
+    InvalidChannelException, InvalidMatchSpecException, InvalidPackageNameException,
+    InvalidUrlException, InvalidVersionException, PyRattlerError,
 };
 use match_spec::PyMatchSpec;
 use nameless_match_spec::PyNamelessMatchSpec;
@@ -23,6 +26,9 @@ fn rattler(py: Python, m: &PyModule) -> PyResult<()> {
 
     m.add_class::<PyPackageRecord>().unwrap();
 
+    m.add_class::<PyChannel>().unwrap();
+    m.add_class::<PyChannelConfig>().unwrap();
+
     // Exceptions
     m.add(
         "InvalidVersionError",
@@ -39,6 +45,13 @@ fn rattler(py: Python, m: &PyModule) -> PyResult<()> {
         py.get_type::<InvalidPackageNameException>(),
     )
     .unwrap();
+    m.add("InvalidUrlError", py.get_type::<InvalidUrlException>())
+        .unwrap();
+    m.add(
+        "InvalidChannelError",
+        py.get_type::<InvalidChannelException>(),
+    )
+    .unwrap();
 
     Ok(())
 }