parquet 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 896f2833b6db8e4466af8fc9d43eb5c695e25a207a6f8050d22052458edded36
-  data.tar.gz: 38de2831bf7013e0194b2e61a91b26a1283fef65a04309dfbe125c570d64e9ed
+  metadata.gz: e1ae8e2c64920df8527a16d7348fc37c5ae2cf5c783b648bed93e31cab25bd72
+  data.tar.gz: 2d7b45349d33679f96559683e31d7c9dd5718fb78611aad057bba92d7324c2d3
 SHA512:
-  metadata.gz: 52d83bc198f789856eac4bff7ff985a82c3f03f75e5de79efc5b388ce5afc63cb507b4cacc90625ee321619ade1ddc16f66f6c437ca0f60d144bc593bbec8cc5
-  data.tar.gz: c6dd98694fd2a1d29ceebec6b58d63220f3992fe4dc63dae1c28ea27f8a353764f87a16a13c95e3e2111bca811c57fde45da9f008a93d8868112b4be608d46ee
+  metadata.gz: 1f56d8e538bdb095e43472940a8c3a57b6b54d74ab87d9c1519878d759962e6d844f9c992927dc22d22ebefee4bd64a858b2ed89ccc3c694d183bcb9fd154497
+  data.tar.gz: 5f5c8914d81ef297bebb021ba40e70725208e61c2bd1565f7d134341ac3c31489b501766266f7390ffde82a44e5821321b55f827467ac95c760cd08588788e9d

data/Cargo.lock

@@ -681,7 +681,7 @@ checksum = "3d87ae53030f3a22e83879e666cb94e58a7bdf31706878a0ba48752994146dab"
 dependencies = [
  "magnus-macros",
  "rb-sys",
- "rb-sys-env",
+ "rb-sys-env 0.1.2",
  "seq-macro",
 ]
 
@@ -839,9 +839,11 @@ dependencies = [
  "jiff",
  "magnus",
  "mimalloc",
+ "num",
  "parquet 54.2.0",
  "rand",
  "rb-sys",
+ "rb-sys-env 0.2.2",
  "simdutf8",
  "tempfile",
  "thiserror",
@@ -997,6 +999,12 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
 
+[[package]]
+name = "rb-sys-env"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08f8d2924cf136a1315e2b4c7460a39f62ef11ee5d522df9b2750fab55b868b6"
+
 [[package]]
 name = "regex"
 version = "1.11.1"

data/ext/parquet/Cargo.toml

@@ -6,6 +6,9 @@ edition = "2021"
 [lib]
 crate-type = ["cdylib"]
 
+[build-dependencies]
+rb-sys-env = "^0.2"
+
 [dependencies]
 ahash = "0.8"
 arrow-array = "54.0.0"
@@ -21,6 +24,7 @@ rb-sys = "^0.9"
 simdutf8 = "0.1.5"
 tempfile = "^3.15"
 thiserror = "2.0"
+num = "0.4.3"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 jemallocator = { version = "0.5", features = ["disable_initial_exec_tls"] }

data/ext/parquet/build.rs

@@ -0,0 +1,5 @@
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let _rb_env = rb_sys_env::activate()?;
+
+    Ok(())
+}

data/ext/parquet/src/lib.rs

@@ -20,6 +20,7 @@ use writer::write_rows;
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("Parquet")?;
+    module.define_module_function("metadata", magnus::method!(reader::parse_metadata, -1))?;
     module.define_module_function("each_row", magnus::method!(parse_parquet_rows, -1))?;
     module.define_module_function("each_column", magnus::method!(parse_parquet_columns, -1))?;
     module.define_module_function("write_rows", magnus::function!(write_rows, -1))?;

data/ext/parquet/src/reader/common.rs

@@ -5,6 +5,7 @@ use parquet::arrow::arrow_reader::{ParquetRecordBatchReader, ParquetRecordBatchR
 use parquet::arrow::ProjectionMask;
 use std::collections::HashMap;
 use std::fs::File;
+use std::rc::Rc;
 use std::sync::Arc;
 
 use magnus::value::ReprValue;
@@ -21,7 +22,7 @@ use crate::ColumnRecord;
 /// returning either a File or a ThreadSafeRubyReader that can be used with
 /// parquet readers.
 pub fn open_parquet_source(
-    ruby: Arc<Ruby>,
+    ruby: Rc<Ruby>,
     to_read: Value,
 ) -> Result<Either<File, ThreadSafeRubyReader>, ParquetGemError> {
     if to_read.is_kind_of(ruby.class_string()) {
@@ -58,8 +59,8 @@ pub fn create_batch_reader<T: parquet::file::reader::ChunkReader + 'static>(
     columns: &Option<Vec<String>>,
     batch_size: Option<usize>,
 ) -> Result<(ParquetRecordBatchReader, std::sync::Arc<Schema>, i64), ParquetGemError> {
-    let mut builder = ParquetRecordBatchReaderBuilder::try_new(reader)
-        .map_err(|e| ParquetGemError::Parquet(e))?;
+    let mut builder =
+        ParquetRecordBatchReaderBuilder::try_new(reader).map_err(ParquetGemError::Parquet)?;
 
     let schema = builder.schema().clone();
     let num_rows = builder.metadata().file_metadata().num_rows();
@@ -78,7 +79,7 @@ pub fn create_batch_reader<T: parquet::file::reader::ChunkReader + 'static>(
         builder = builder.with_batch_size(batch_size);
     }
 
-    let reader = builder.build().map_err(|e| ParquetGemError::Parquet(e))?;
+    let reader = builder.build().map_err(ParquetGemError::Parquet)?;
     Ok((reader, schema, num_rows))
 }
 
@@ -98,12 +99,12 @@ pub fn handle_empty_file(
             .map(|field| field.name().to_string())
             .collect();
         let interned_headers =
-            StringCache::intern_many(&headers).map_err(|e| ParquetGemError::HeaderIntern(e))?;
+            StringCache::intern_many(&headers).map_err(ParquetGemError::HeaderIntern)?;
         for field in interned_headers.iter() {
             map.insert(*field, vec![]);
         }
         let record = ColumnRecord::Map(map);
-        let _: Value = ruby.yield_value(record.try_into_value_with(&ruby)?)?;
+        let _: Value = ruby.yield_value(record.try_into_value_with(ruby)?)?;
         return Ok(true);
     }
     Ok(false)

data/ext/parquet/src/reader/mod.rs

@@ -1,6 +1,210 @@
 mod common;
 mod parquet_column_reader;
 mod parquet_row_reader;
+use std::{fs::File, rc::Rc};
 
+use magnus::{value::ReprValue, Error as MagnusError, Ruby, Value};
+use parquet::file::metadata::{ParquetMetaData, ParquetMetaDataReader};
 pub use parquet_column_reader::parse_parquet_columns;
 pub use parquet_row_reader::parse_parquet_rows;
+
+use crate::{
+    ruby_reader::{RubyReader, ThreadSafeRubyReader},
+    types::{ParquetGemError, TryIntoValue},
+};
+
+struct RubyParquetMetaData(ParquetMetaData);
+
+impl TryIntoValue for RubyParquetMetaData {
+    fn try_into_value_with(self, handle: &Ruby) -> Result<Value, ParquetGemError> {
+        let metadata = self.0;
+        let file_metadata = metadata.file_metadata();
+        let row_groups = metadata.row_groups();
+
+        // Construct a hash with the metadata
+        let hash = handle.hash_new();
+        hash.aset("num_rows", file_metadata.num_rows())?;
+        hash.aset("created_by", file_metadata.created_by())?;
+        // Convert key_value_metadata to a Ruby array if it exists
+        if let Some(key_value_metadata) = file_metadata.key_value_metadata() {
+            let kv_array = handle.ary_new();
+            for kv in key_value_metadata {
+                let kv_hash = handle.hash_new();
+                kv_hash.aset("key", kv.key.clone())?;
+                kv_hash.aset("value", kv.value.clone())?;
+                kv_array.push(kv_hash)?;
+            }
+            hash.aset("key_value_metadata", kv_array)?;
+        } else {
+            hash.aset("key_value_metadata", None::<Value>)?;
+        }
+
+        // Convert schema to a Ruby hash since &Type doesn't implement IntoValue
+        let schema_hash = handle.hash_new();
+        let schema = file_metadata.schema();
+        schema_hash.aset("name", schema.name())?;
+        // Add schema fields information
+        let fields_array = handle.ary_new();
+        for field in schema.get_fields() {
+            let field_hash = handle.hash_new();
+            field_hash.aset("name", field.name())?;
+
+            // Handle different field types
+            match field.as_ref() {
+                parquet::schema::types::Type::PrimitiveType {
+                    physical_type,
+                    type_length,
+                    scale,
+                    precision,
+                    ..
+                } => {
+                    field_hash.aset("type", "primitive")?;
+                    field_hash.aset("physical_type", format!("{:?}", physical_type))?;
+                    field_hash.aset("type_length", *type_length)?;
+                    field_hash.aset("scale", *scale)?;
+                    field_hash.aset("precision", *precision)?;
+                }
+                parquet::schema::types::Type::GroupType { .. } => {
+                    field_hash.aset("type", "group")?;
+                }
+            }
+
+            // Add basic info
+            let basic_info = field.get_basic_info();
+            field_hash.aset("repetition", format!("{:?}", basic_info.repetition()))?;
+            field_hash.aset(
+                "converted_type",
+                format!("{:?}", basic_info.converted_type()),
+            )?;
+            if let Some(logical_type) = basic_info.logical_type() {
+                field_hash.aset("logical_type", format!("{:?}", logical_type))?;
+            }
+
+            fields_array.push(field_hash)?;
+        }
+        schema_hash.aset("fields", fields_array)?;
+
+        hash.aset("schema", schema_hash)?;
+
+        // Convert row_groups to a Ruby array since &[RowGroupMetaData] doesn't implement IntoValue
+        let row_groups_array = handle.ary_new();
+        for row_group in row_groups.iter() {
+            let rg_hash = handle.hash_new();
+            rg_hash.aset("num_columns", row_group.num_columns())?;
+            rg_hash.aset("num_rows", row_group.num_rows())?;
+            rg_hash.aset("total_byte_size", row_group.total_byte_size())?;
+            rg_hash.aset("file_offset", row_group.file_offset())?;
+            rg_hash.aset("ordinal", row_group.ordinal())?;
+            rg_hash.aset("compressed_size", row_group.compressed_size())?;
+
+            // Add column chunks metadata
+            let columns_array = handle.ary_new();
+            for col_idx in 0..row_group.num_columns() {
+                let column = row_group.column(col_idx);
+                let col_hash = handle.hash_new();
+
+                col_hash.aset("column_path", column.column_path().string())?;
+                col_hash.aset("file_path", column.file_path())?;
+                col_hash.aset("file_offset", column.file_offset())?;
+                col_hash.aset("num_values", column.num_values())?;
+                col_hash.aset("compression", format!("{:?}", column.compression()))?;
+                col_hash.aset("total_compressed_size", column.compressed_size())?;
+                col_hash.aset("total_uncompressed_size", column.uncompressed_size())?;
+                col_hash.aset("data_page_offset", column.data_page_offset())?;
+
+                if let Some(offset) = column.dictionary_page_offset() {
+                    col_hash.aset("dictionary_page_offset", offset)?;
+                }
+
+                if let Some(offset) = column.bloom_filter_offset() {
+                    col_hash.aset("bloom_filter_offset", offset)?;
+                }
+
+                if let Some(length) = column.bloom_filter_length() {
+                    col_hash.aset("bloom_filter_length", length)?;
+                }
+
+                if let Some(offset) = column.offset_index_offset() {
+                    col_hash.aset("offset_index_offset", offset)?;
+                }
+
+                if let Some(length) = column.offset_index_length() {
+                    col_hash.aset("offset_index_length", length)?;
+                }
+
+                if let Some(offset) = column.column_index_offset() {
+                    col_hash.aset("column_index_offset", offset)?;
+                }
+
+                if let Some(length) = column.column_index_length() {
+                    col_hash.aset("column_index_length", length)?;
+                }
+
+                // Add encodings
+                let encodings_array = handle.ary_new();
+                for encoding in column.encodings() {
+                    encodings_array.push(format!("{:?}", encoding))?;
+                }
+                col_hash.aset("encodings", encodings_array)?;
+
+                // Add statistics if available
+                if let Some(stats) = column.statistics() {
+                    let stats_hash = handle.hash_new();
+                    stats_hash.aset("min_is_exact", stats.min_is_exact())?;
+                    stats_hash.aset("max_is_exact", stats.max_is_exact())?;
+
+                    col_hash.aset("statistics", stats_hash)?;
+                }
+
+                // Add page encoding stats if available
+                if let Some(page_encoding_stats) = column.page_encoding_stats() {
+                    let page_stats_array = handle.ary_new();
+                    for stat in page_encoding_stats {
+                        let stat_hash = handle.hash_new();
+                        stat_hash.aset("page_type", format!("{:?}", stat.page_type))?;
+                        stat_hash.aset("encoding", format!("{:?}", stat.encoding))?;
+                        stat_hash.aset("count", stat.count)?;
+                        page_stats_array.push(stat_hash)?;
+                    }
+                    col_hash.aset("page_encoding_stats", page_stats_array)?;
+                }
+
+                columns_array.push(col_hash)?;
+            }
+            rg_hash.aset("columns", columns_array)?;
+
+            row_groups_array.push(rg_hash)?;
+        }
+        hash.aset("row_groups", row_groups_array)?;
+
+        Ok(handle.into_value(hash))
+    }
+}
+
+pub fn parse_metadata(_rb_self: Value, args: &[Value]) -> Result<Value, MagnusError> {
+    let ruby = unsafe { Ruby::get_unchecked() };
+
+    if args.len() != 1 {
+        return Err(MagnusError::new(
+            magnus::exception::arg_error(),
+            format!("metadata expects exactly 1 argument (file path or IO-like object), got {}", args.len()),
+        ));
+    }
+
+    let ruby = Rc::new(ruby);
+    let arg = args[0];
+
+    let mut reader = ParquetMetaDataReader::new();
+    if arg.is_kind_of(ruby.class_string()) {
+        let path = arg.to_r_string()?.to_string()?;
+        let file = File::open(path).map_err(ParquetGemError::FileOpen)?;
+        reader.try_parse(&file).map_err(ParquetGemError::Parquet)?;
+    } else {
+        let file = ThreadSafeRubyReader::new(RubyReader::new(ruby.clone(), arg)?);
+        reader.try_parse(&file).map_err(ParquetGemError::Parquet)?;
+    }
+
+    let metadata = reader.finish().map_err(ParquetGemError::Parquet)?;
+
+    Ok(RubyParquetMetaData(metadata).try_into_value_with(&ruby)?)
+}

data/ext/parquet/src/reader/parquet_column_reader.rs

@@ -10,26 +10,25 @@ use either::Either;
 use magnus::IntoValue;
 use magnus::{Error as MagnusError, Ruby, Value};
 use std::collections::HashMap;
-use std::sync::{Arc, OnceLock};
+use std::rc::Rc;
+use std::sync::OnceLock;
 
 use super::common::{
     create_batch_reader, handle_block_or_enum, handle_empty_file, open_parquet_source,
 };
 
 #[inline]
-pub fn parse_parquet_columns<'a>(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError> {
+pub fn parse_parquet_columns(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError> {
     let ruby = unsafe { Ruby::get_unchecked() };
-    Ok(
-        parse_parquet_columns_impl(Arc::new(ruby), rb_self, args).map_err(|e| {
-            let z: MagnusError = e.into();
-            z
-        })?,
-    )
+    parse_parquet_columns_impl(Rc::new(ruby), rb_self, args).map_err(|e| {
+        let z: MagnusError = e.into();
+        z
+    })
 }
 
 #[inline]
-fn parse_parquet_columns_impl<'a>(
-    ruby: Arc<Ruby>,
+fn parse_parquet_columns_impl(
+    ruby: Rc<Ruby>,
     rb_self: Value,
     args: &[Value],
 ) -> Result<Value, ParquetGemError> {
@@ -76,13 +75,13 @@ fn parse_parquet_columns_impl<'a>(
         Either::Right(readable) => create_batch_reader(readable, &columns, batch_size)?,
     };
 
-    // Handle empty file case
-    if handle_empty_file(&ruby, &schema, num_rows)? {
-        return Ok(ruby.qnil().into_value_with(&ruby));
-    }
-
     match result_type {
         ParserResultType::Hash => {
+            // For hash return type, we need to return a hash with column names pointing at empty arrays
+            if handle_empty_file(&ruby, &schema, num_rows)? {
+                return Ok(ruby.qnil().into_value_with(&ruby));
+            }
+
             let headers = OnceLock::new();
             let headers_clone = headers.clone();
             let iter = batch_reader.map(move |batch| {
@@ -112,8 +111,8 @@ fn parse_parquet_columns_impl<'a>(
                         .try_for_each(|(i, column)| {
                             let header = local_headers[i];
                             let values = ParquetValueVec::try_from(ArrayWrapper {
-                                array: &*column,
-                                strict: strict,
+                                array: column,
+                                strict,
                             })?;
                             map.insert(header, values.into_inner());
                             Ok::<_, ParquetGemError>(())
@@ -133,11 +132,11 @@ fn parse_parquet_columns_impl<'a>(
                 batch.map_err(ParquetGemError::Arrow).and_then(|batch| {
                     let vec = batch
                         .columns()
-                        .into_iter()
+                        .iter()
                         .map(|column| {
                             let values = ParquetValueVec::try_from(ArrayWrapper {
-                                array: &*column,
-                                strict: strict,
+                                array: column,
+                                strict,
                             })?;
                             Ok::<_, ParquetGemError>(values.into_inner())
                         })

data/ext/parquet/src/reader/parquet_row_reader.rs

@@ -13,24 +13,23 @@ use parquet::file::reader::{FileReader, SerializedFileReader};
 use parquet::record::reader::RowIter as ParquetRowIter;
 use parquet::schema::types::{Type as SchemaType, TypePtr};
 use std::collections::HashMap;
-use std::sync::{Arc, OnceLock};
+use std::rc::Rc;
+use std::sync::OnceLock;
 
 use super::common::{handle_block_or_enum, open_parquet_source};
 
 #[inline]
-pub fn parse_parquet_rows<'a>(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError> {
+pub fn parse_parquet_rows(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError> {
     let ruby = unsafe { Ruby::get_unchecked() };
-    Ok(
-        parse_parquet_rows_impl(Arc::new(ruby), rb_self, args).map_err(|e| {
-            let z: MagnusError = e.into();
-            z
-        })?,
-    )
+    parse_parquet_rows_impl(Rc::new(ruby), rb_self, args).map_err(|e| {
+        let z: MagnusError = e.into();
+        z
+    })
 }
 
 #[inline]
-fn parse_parquet_rows_impl<'a>(
-    ruby: Arc<Ruby>,
+fn parse_parquet_rows_impl(
+    ruby: Rc<Ruby>,
     rb_self: Value,
     args: &[Value],
 ) -> Result<Value, ParquetGemError> {
@@ -93,7 +92,7 @@ fn parse_parquet_rows_impl<'a>(
             let headers = OnceLock::new();
             let headers_clone = headers.clone();
             let iter = iter.map(move |row| {
-                row.and_then(|row| {
+                row.map(|row| {
                     let headers = headers_clone.get_or_init(|| {
                         let column_count = row.get_column_iter().count();
 
@@ -102,10 +101,7 @@ fn parse_parquet_rows_impl<'a>(
                             header_string.push(k.to_owned());
                         }
 
-                        let headers = StringCache::intern_many(&header_string)
-                            .expect("Failed to intern headers");
-
-                        headers
+                        StringCache::intern_many(&header_string).expect("Failed to intern headers")
                     });
 
                     let mut map =
@@ -113,10 +109,10 @@ fn parse_parquet_rows_impl<'a>(
                     for (i, (_, v)) in row.get_column_iter().enumerate() {
                         map.insert(headers[i], ParquetField(v.clone(), strict));
                     }
-                    Ok(map)
+                    map
                 })
-                .and_then(|row| Ok(RowRecord::Map::<RandomState>(row)))
-                .map_err(|e| ParquetGemError::from(e))
+                .map(RowRecord::Map::<RandomState>)
+                .map_err(ParquetGemError::from)
             });
 
             for result in iter {
@@ -126,16 +122,16 @@ fn parse_parquet_rows_impl<'a>(
         }
         ParserResultType::Array => {
             let iter = iter.map(|row| {
-                row.and_then(|row| {
+                row.map(|row| {
                     let column_count = row.get_column_iter().count();
                     let mut vec = Vec::with_capacity(column_count);
                     for (_, v) in row.get_column_iter() {
                         vec.push(ParquetField(v.clone(), strict));
                     }
-                    Ok(vec)
+                    vec
                 })
-                .and_then(|row| Ok(RowRecord::Vec::<RandomState>(row)))
-                .map_err(|e| ParquetGemError::from(e))
+                .map(RowRecord::Vec::<RandomState>)
+                .map_err(ParquetGemError::from)
             });
 
             for result in iter {

data/ext/parquet/src/ruby_reader.rs

@@ -7,7 +7,7 @@ use parquet::{
     errors::ParquetError,
     file::reader::{ChunkReader, Length},
 };
-use std::{fs::File, sync::Mutex};
+use std::{fs::File, rc::Rc, sync::Mutex};
 use std::{
     io::{self, BufReader, Read, Seek, SeekFrom, Write},
     sync::Arc,
@@ -35,7 +35,7 @@ pub enum RubyReader {
 unsafe impl Send for RubyReader {}
 
 impl RubyReader {
-    pub fn new(ruby: Arc<Ruby>, value: Value) -> Result<Self, ParquetGemError> {
+    pub fn new(ruby: Rc<Ruby>, value: Value) -> Result<Self, ParquetGemError> {
         if RubyReader::is_seekable_io_like(&value) {
             Ok(RubyReader::RubyIoLike {
                 inner: Opaque::from(value),
@@ -165,9 +165,7 @@ impl Read for RubyReader {
                         buf.write_all(string_buffer)?;
                         Ok(string_buffer.len())
                     }
-                    None => {
-                        return Ok(0);
-                    }
+                    None => Ok(0),
                 }
             }
         }

data/ext/parquet/src/types/core_types.rs

@@ -107,6 +107,7 @@ pub enum PrimitiveType {
     UInt64,
     Float32,
     Float64,
+    Decimal128(u8, i8),
     Boolean,
     String,
     Binary,

data/ext/parquet/src/types/mod.rs

@@ -32,6 +32,7 @@ use arrow_schema::{DataType, TimeUnit};
 use magnus::{value::ReprValue, Error as MagnusError, IntoValue, Ruby, Value};
 use parquet::data_type::Decimal;
 use parquet::record::Field;
+use std::array::TryFromSliceError;
 use std::{collections::HashMap, hash::BuildHasher, sync::Arc};
 
 use crate::header_cache::StringCacheKey;
@@ -58,6 +59,8 @@ pub enum ParquetGemError {
     Utf8Error(#[from] simdutf8::basic::Utf8Error),
     #[error("Jiff error: {0}")]
     Jiff(#[from] jiff::Error),
+    #[error("Failed to cast slice to array: {0}")]
+    InvalidDecimal(#[from] TryFromSliceError),
 }
 
 #[derive(Debug)]
@@ -83,11 +86,11 @@ impl From<MagnusError> for ParquetGemError {
     }
 }
 
-impl Into<MagnusError> for ParquetGemError {
-    fn into(self) -> MagnusError {
-        match self {
-            Self::Ruby(MagnusErrorWrapper(err)) => err.into(),
-            _ => MagnusError::new(magnus::exception::runtime_error(), self.to_string()),
+impl From<ParquetGemError> for MagnusError {
+    fn from(val: ParquetGemError) -> Self {
+        match val {
+            ParquetGemError::Ruby(MagnusErrorWrapper(err)) => err,
+            _ => MagnusError::new(magnus::exception::runtime_error(), val.to_string()),
         }
     }
 }