remove many

Cargo.toml

@@ -192,7 +192,7 @@ tokio = {version = "1.37.0", features = [
 ]}
 tokio-stream = {version = "0.1.14", features = ["fs", "io-util", "time"]}
 tokio-util = "0.7.11"
-tracing = "0.1.40"
+tracing = "0.1"
 url = "2.4.0"
 
 [workspace.dependencies.arrow2]

src/daft-core/Cargo.toml

@@ -43,7 +43,6 @@ pyo3 = {workspace = true, optional = true}
 regex = {workspace = true}
 serde = {workspace = true}
 sketches-ddsketch = {workspace = true}
-tracing = {workspace = true}
 unicode-normalization = "0.1.23"
 
 [dependencies.numpy]

src/daft-core/src/array/ops/from_arrow.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use common_error::{DaftError, DaftResult};
-use log::info;
 
 use crate::{
     array::{DataArray, FixedSizeListArray, ListArray, StructArray},
@@ -30,15 +29,12 @@ impl<L: DaftLogicalType> FromArrow for LogicalArray<L>
 where
     <L::PhysicalType as DaftDataType>::ArrayType: FromArrow,
 {
-    #[tracing::instrument(level = "trace", name = "LogicalArray::from_arrow", skip_all)]
     fn from_arrow(field: FieldRef, arrow_arr: Box<dyn arrow2::array::Array>) -> DaftResult<Self> {
         let target_convert = field.to_physical();
         let target_convert_arrow = target_convert.dtype.to_arrow()?;
 
         let physical_arrow_array = arrow_arr.convert_logical_type(target_convert_arrow.clone());
 
-        let dbg = format!("Target Convert: {target_convert:#?}\nTarget Convert Arrow: {target_convert_arrow:#?}\nPhysical Arrow: {:#?}", physical_arrow_array.data_type());
-
         let physical = <L::PhysicalType as DaftDataType>::ArrayType::from_arrow(
             Arc::new(target_convert),
             physical_arrow_array,
@@ -132,8 +128,6 @@ impl FromArrow for StructArray {
                     return Err(DaftError::ValueError(format!("Attempting to create Daft StructArray with {} fields from Arrow array with {} fields: {} vs {:?}", fields.len(), arrow_fields.len(), &field.dtype, arrow_arr.data_type())));
                 }
 
-                let debug = format!("{field:#?}");
-
                 let arrow_arr = arrow_arr.as_ref().as_any().downcast_ref::<arrow2::array::StructArray>().unwrap();
                 let arrow_child_arrays = arrow_arr.values();
 

src/daft-core/src/series/from.rs

@@ -50,7 +50,6 @@ impl Series {
 impl TryFrom<(&str, Box<dyn arrow2::array::Array>)> for Series {
     type Error = DaftError;
 
-    #[instrument(level = "trace", name = "Series::try_from", skip_all)]
     fn try_from((name, array): (&str, Box<dyn arrow2::array::Array>)) -> DaftResult<Self> {
         let source_arrow_type: &ArrowDataType = array.data_type();
         let dtype = DaftDataType::from(source_arrow_type);

src/daft-schema/src/dtype.rs

@@ -618,9 +618,7 @@ impl DataType {
 }
 
 impl From<&ArrowType> for DataType {
-    #[tracing::instrument(level = "trace", name = "DataType::from(&ArrowType)", skip(item))]
     fn from(item: &ArrowType) -> Self {
-        tracing::trace!("processing {item:#?}");
         let result = match item {
             ArrowType::Null => Self::Null,
             ArrowType::Boolean => Self::Boolean,
@@ -697,7 +695,6 @@ impl From<&ArrowType> for DataType {
             _ => panic!("DataType :{item:?} is not supported"),
         };
 
-        tracing::info!("Result: {result:?}");
         result
     }
 }

tests/expressions/test_expressions.py

@@ -516,16 +516,6 @@ def test_list_value_counts():
         {"list_col": [["a", "b", "a", "c"], ["b", "b", "c"], ["a", "a", "a"], [], ["d", None, "d"]]}
     )
 
-    # mp = MicroPartition.from_pydict({
-    #     "list_col": [
-    #         ["a", "b", "a", "c"],
-    #         ["b", "b", "c"],
-    #         ["a", "a", "a"],
-    #         [],
-    #         ["d", "d"]
-    #     ]
-    # })
-
     # # Apply list_value_counts operation
     result = mp.eval_expression_list([col("list_col").list.value_counts().alias("value_counts")])
     value_counts = result.to_pydict()["value_counts"]
@@ -536,9 +526,6 @@ def test_list_value_counts():
     # Check the result
     assert value_counts == expected
 
-    # Test with empty input
-    empty_mp = MicroPartition.from_pydict({"list_col": []})
-
     # Test with empty input (no proper type -> should raise error)
     empty_mp = MicroPartition.from_pydict({"list_col": []})
     with pytest.raises(ValueError):