Published packages cannot depend on unpublished packages (#6592)

We need to write a CI check for this but for now this fixes the
immediate problem

Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

Cargo.lock

@@ -63,10 +63,6 @@ vortex-array = { workspace = true, features = ["_test-harness"] }
 vortex-io = { workspace = true, features = ["tokio"] }
 vortex-scan = { workspace = true }
 
-[target.'cfg(unix)'.dev-dependencies]
-vortex-cuda = { workspace = true }
-vortex-cuda-macros = { workspace = true }
-
 [lints]
 workspace = true
 

vortex-file/Cargo.toml

@@ -51,8 +51,6 @@ use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_buffer::buffer;
-#[cfg(unix)]
-use vortex_cuda_macros::cuda_tests;
 use vortex_dtype::DType;
 use vortex_dtype::DecimalDType;
 use vortex_dtype::Nullability;
@@ -1636,130 +1634,3 @@ async fn main_test() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
-
-#[cfg(unix)]
-#[cuda_tests]
-mod cuda_tests {
-    use std::sync::Arc;
-    use std::sync::LazyLock;
-
-    use futures::StreamExt;
-    use vortex_array::IntoArray;
-    use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::arrays::StructArray;
-    use vortex_array::arrays::VarBinViewArray;
-    use vortex_array::expr::session::ExprSession;
-    use vortex_array::session::ArraySession;
-    use vortex_array::validity::Validity;
-    use vortex_buffer::buffer;
-    use vortex_cuda::CanonicalCudaExt;
-    use vortex_cuda::CopyDeviceReadAt;
-    use vortex_cuda::CudaSession;
-    use vortex_cuda::CudaSessionExt;
-    use vortex_cuda::executor::CudaArrayExt;
-    use vortex_dtype::FieldNames;
-    use vortex_error::VortexResult;
-    use vortex_io::session::RuntimeSession;
-    use vortex_io::session::RuntimeSessionExt;
-    use vortex_io::std_file::FileReadAt;
-    use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
-    use vortex_layout::session::LayoutSession;
-    use vortex_session::VortexSession;
-
-    use crate::OpenOptionsSessionExt;
-    use crate::WriteOptionsSessionExt;
-
-    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-        let mut session = VortexSession::empty()
-            .with::<ArraySession>()
-            .with::<LayoutSession>()
-            .with::<ExprSession>()
-            .with::<RuntimeSession>()
-            .with::<CudaSession>();
-
-        vortex_cuda::initialize_cuda(&session.cuda_session());
-        crate::register_default_encodings(&mut session);
-
-        session
-    });
-
-    #[tokio::test]
-    async fn gpu_scan() -> VortexResult<()> {
-        use vortex_alp::alp_encode;
-
-        assert!(
-            std::env::var("FLAT_LAYOUT_INLINE_ARRAY_NODE").is_ok(),
-            "gpu_scan test must be run with FLAT_LAYOUT_INLINE_ARRAY_NODE=1"
-        );
-
-        // Create an ALP-encoded array from primitive f64 values
-        let primitive = PrimitiveArray::from_iter((0..100).map(|i| i as f64 * 1.1));
-        let alp_array = alp_encode(&primitive, None)?;
-        let str_array = VarBinViewArray::from_iter_str((0..100).map(|i| format!("number {i}")));
-        let array = StructArray::new(
-            FieldNames::from(vec!["float_col", "int_col", "str_col"]),
-            vec![
-                primitive.into_array(),
-                alp_array.into_array(),
-                str_array.into_array(),
-            ],
-            100,
-            Validity::NonNullable,
-        );
-
-        let flat_strategy = Arc::new(FlatLayoutStrategy::default());
-
-        // Write to a buffer, then to a temp file
-        let temp_path = std::env::temp_dir().join("gpu_scan_test.vortex");
-        let mut buf = Vec::new();
-        SESSION
-            .write_options()
-            // write with flat strategy, don't try and compress
-            .with_strategy(flat_strategy)
-            .write(&mut buf, array.to_array_stream())
-            .await?;
-        std::fs::write(&temp_path, &buf)?;
-
-        // Read back via GPU
-        let handle = SESSION.handle();
-        let source = Arc::new(FileReadAt::open(&temp_path, handle)?);
-        let gpu_reader =
-            CopyDeviceReadAt::new(source.clone(), SESSION.cuda_session().new_stream()?);
-        let cpu_reader = source;
-
-        let cpu_file = SESSION.open_options().open_read(cpu_reader).await?;
-        let gpu_file = SESSION
-            .open_options()
-            .with_footer(cpu_file.footer)
-            .open_read(gpu_reader)
-            .await?;
-
-        let mut cuda_ctx = CudaSession::create_execution_ctx(&SESSION)?;
-
-        let mut res = Vec::new();
-        let mut stream = gpu_file
-            .scan()?
-            // filter with a predefined mask
-            .with_row_indices(buffer![0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
-            .into_array_stream()?;
-        while let Some(a) = stream.next().await {
-            let a = a?;
-            let array = a
-                .execute_cuda(&mut cuda_ctx)
-                .await?
-                .into_host()
-                .await?
-                .into_array();
-            res.push(array);
-        }
-
-        for a in res {
-            println!("a {} ", a.display_tree())
-        }
-
-        // Cleanup
-        std::fs::remove_file(&temp_path)?;
-
-        Ok(())
-    }
-}

vortex-file/src/tests.rs

@@ -36,12 +36,6 @@ tokio = { workspace = true, features = ["rt-multi-thread"] }
 vortex = { workspace = true, features = ["tokio"] }
 vortex-datafusion = { workspace = true }
 
-[target.'cfg(target_os = "linux")'.dependencies]
-vortex-cuda = { workspace = true, optional = true }
-
-[features]
-cuda = ["dep:vortex-cuda"]
-
 [lints]
 workspace = true
 

vortex-tui/Cargo.toml

@@ -31,9 +31,6 @@ pub enum Strategy {
     Btrblocks,
     /// Use the Compact compression strategy for more aggressive compression.
     Compact,
-    #[cfg(all(target_os = "linux", feature = "cuda"))]
-    /// Use CUDA-compatible encodings with CudaFlatLayout.
-    Cuda,
 }
 
 /// Command-line flags for the convert command.
@@ -98,15 +95,6 @@ pub async fn exec_convert(session: &VortexSession, flags: ConvertArgs) -> anyhow
     let strategy = match flags.strategy {
         Strategy::Btrblocks => strategy,
         Strategy::Compact => strategy.with_compact_encodings(),
-        #[cfg(all(target_os = "linux", feature = "cuda"))]
-        Strategy::Cuda => {
-            use std::sync::Arc;
-            strategy
-                .with_cuda_compatible_encodings()
-                .with_flat_strategy(Arc::new(
-                    vortex_cuda::layout::CudaFlatLayoutStrategy::default(),
-                ))
-        }
     };
 
     let mut file = File::create(output_path).await?;