feat: pixi project export conda to export project to conda environment.yml's

src/cli/project/export/conda.rs

@@ -0,0 +1,80 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+
+use itertools::Itertools;
+use miette::IntoDiagnostic;
+use rattler_conda_types::Platform;
+
+use crate::utils::conda_environment_file::{CondaEnvDep, CondaEnvFile};
+use crate::{HasFeatures, Project};
+
+/// Exports a projects dependencies as an environment.yml
+///
+/// The environment is printed to standard out
+#[derive(Debug, Parser)]
+#[clap(arg_required_else_help = false)]
+pub struct Args {
+    /// The platform to list packages for. Defaults to the current platform.
+    #[arg(long)]
+    pub platform: Option<Platform>,
+
+    /// The path to 'pixi.toml' or 'pyproject.toml'
+    #[arg(long)]
+    pub manifest_path: Option<PathBuf>,
+
+    /// The environment to list packages for. Defaults to the default environment.
+    #[arg(short, long)]
+    pub environment: Option<String>,
+
+    /// Name for environment
+    #[arg(short, long)]
+    pub name: Option<String>,
+}
+
+pub async fn execute(args: Args) -> miette::Result<()> {
+    let project = Project::load_or_else_discover(args.manifest_path.as_deref())?;
+    let environment = project.environment_from_name_or_env_var(args.environment)?;
+
+    let platform = args.platform.unwrap_or_else(|| environment.best_platform());
+
+    let name = match args.name {
+        Some(arg_name) => arg_name,
+        None => format!("{}-{}-{}", project.name(), environment.name(), platform),
+    };
+
+    let channels = environment
+        .channels()
+        .into_iter()
+        .map(|channel| channel.name().to_string())
+        .collect_vec();
+
+    let mut dependencies = environment
+        .dependencies(None, Some(platform))
+        .into_specs()
+        .map(|(name, _spec)| CondaEnvDep::Conda(name.as_source().to_string()))
+        .collect_vec();
+
+    let pypi_dependencies = environment
+        .pypi_dependencies(Some(platform))
+        .into_specs()
+        .map(|(name, _spec)| name.as_source().to_string())
+        .collect_vec();
+
+    if !pypi_dependencies.is_empty() {
+        dependencies.push(CondaEnvDep::Pip {
+            pip: pypi_dependencies,
+        });
+    }
+
+    let env_file = CondaEnvFile {
+        name: Some(name),
+        channels,
+        dependencies,
+    };
+
+    let env_string = serde_yaml::to_string(&env_file).into_diagnostic()?;
+    println!("{}", env_string);
+
+    Ok(())
+}

src/cli/project/export/mod.rs

@@ -0,0 +1,23 @@
+use clap::Parser;
+
+mod conda;
+
+#[derive(Debug, Parser)]
+pub enum Command {
+    #[clap(alias = "c")]
+    Conda(conda::Args),
+}
+
+/// Commands for exporting dependencies to additional formats
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[command(subcommand)]
+    command: Command,
+}
+
+pub async fn execute(cmd: Args) -> miette::Result<()> {
+    match cmd.command {
+        Command::Conda(args) => conda::execute(args).await?,
+    };
+    Ok(())
+}

src/cli/project/mod.rs

@@ -3,13 +3,15 @@ use std::path::PathBuf;
 
 pub mod channel;
 pub mod description;
+pub mod export;
 pub mod platform;
 pub mod version;
 
 #[derive(Debug, Parser)]
 pub enum Command {
     Channel(channel::Args),
     Description(description::Args),
+    Export(export::Args),
     Platform(platform::Args),
     Version(version::Args),
 }
@@ -28,6 +30,7 @@ pub async fn execute(cmd: Args) -> miette::Result<()> {
     match cmd.command {
         Command::Channel(args) => channel::execute(args).await?,
         Command::Description(args) => description::execute(args).await?,
+        Command::Export(cmd) => export::execute(cmd).await?,
         Command::Platform(args) => platform::execute(args).await?,
         Command::Version(args) => version::execute(args).await?,
     };

src/utils/conda_environment_file.rs

@@ -2,22 +2,22 @@ use itertools::Itertools;
 use miette::IntoDiagnostic;
 use rattler_conda_types::ParseStrictness::Lenient;
 use rattler_conda_types::{Channel, MatchSpec};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 use std::{io::BufRead, path::Path, sync::Arc};
 
 use crate::config::Config;
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct CondaEnvFile {
     #[serde(default)]
-    name: Option<String>,
+    pub name: Option<String>,
     #[serde(default)]
-    channels: Vec<String>,
-    dependencies: Vec<CondaEnvDep>,
+    pub channels: Vec<String>,
+    pub dependencies: Vec<CondaEnvDep>,
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(untagged)]
 pub enum CondaEnvDep {
     Conda(String),