From 85b88ff429d3970274bb0d8582dc93404cffd3ca Mon Sep 17 00:00:00 2001 From: Sameeul Samee Date: Tue, 17 Feb 2026 08:46:01 -0500 Subject: [PATCH 1/4] Update to tensorstore v0.1.80 to support zarr v3 --- .github/workflows/publish_pypi.yml | 10 +- .github/workflows/wheel_build.yml | 11 +- CMakeLists.txt | 4 +- ci-utils/install_prereq_linux.sh | 66 +++++---- setup.py | 7 +- src/cpp/ts_driver/ometiff/driver.cc | 129 +++++++++++------- src/cpp/ts_driver/ometiff/metadata.cc | 4 +- .../tiled_tiff/tiled_tiff_key_value_store.cc | 61 +++++---- 8 files changed, 172 insertions(+), 120 deletions(-) diff --git a/.github/workflows/publish_pypi.yml b/.github/workflows/publish_pypi.yml index 77b23f6..7c8b2fb 100644 --- a/.github/workflows/publish_pypi.yml +++ b/.github/workflows/publish_pypi.yml @@ -41,7 +41,7 @@ jobs: - uses: actions/setup-python@v4 name: Install Python with: - python-version: '3.9' + python-version: '3.11' - name: Install cibuildwheel run: | @@ -58,6 +58,8 @@ jobs: CIBW_BEFORE_ALL_MACOS: brew install nasm && bash ci-utils/install_prereq_linux.sh && mkdir -p /tmp/argolid_bld && + brew uninstall --ignore-dependencies openssl || true && + sudo rm -rf /usr/local/include/openssl && cp -r local_install /tmp/argolid_bld CIBW_BEFORE_ALL_LINUX: curl -L https://www.nasm.us/pub/nasm/releasebuilds/2.15.05/nasm-2.15.05.tar.bz2 -o nasm-2.15.05.tar.bz2 && tar -xjf nasm-2.15.05.tar.bz2 && @@ -77,7 +79,11 @@ jobs: ON_GITHUB="TRUE" ARGOLID_DEP_DIR="/tmp/argolid_bld/local_install" CMAKE_ARGS="-DCMAKE_CXX_FLAGS=-Wno-missing-template-arg-list-after-template-kw -DTENSORSTORE_USE_SYSTEM_JPEG=ON -DTENSORSTORE_USE_SYSTEM_ZLIB=ON -DTENSORSTORE_USE_SYSTEM_PNG=ON" - CIBW_ENVIRONMENT_LINUX: LD_LIBRARY_PATH="/tmp/argolid_bld/local_install/lib:/tmp/argolid_bld/local_install/lib64:$LD_LIBRARY_PATH" ON_GITHUB="TRUE" ARGOLID_DEP_DIR="/tmp/argolid_bld/local_install" + CIBW_ENVIRONMENT_LINUX: >- + LD_LIBRARY_PATH="/tmp/argolid_bld/local_install/lib:/tmp/argolid_bld/local_install/lib64:$LD_LIBRARY_PATH" + ON_GITHUB="TRUE" + ARGOLID_DEP_DIR="/tmp/argolid_bld/local_install" + CMAKE_ARGS="-DTENSORSTORE_USE_SYSTEM_JPEG=ON -DTENSORSTORE_USE_SYSTEM_ZLIB=ON -DTENSORSTORE_USE_SYSTEM_PNG=ON" CIBW_REPAIR_WHEEL_COMMAND_MACOS: DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-listdeps {wheel} && DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-wheel --require-archs {delocate_archs} -w {dest_dir} {wheel} CIBW_ENVIRONMENT_WINDOWS: PATH="$TEMP\\argolid\\bin;$PATH" ON_GITHUB="TRUE" ARGOLID_DEP_DIR="C:\\TEMP\\argolid_bld\\local_install" CMAKE_ARGS="-DCMAKE_GENERATOR=Ninja" CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: "delvewheel repair -w {dest_dir} {wheel}" diff --git a/.github/workflows/wheel_build.yml b/.github/workflows/wheel_build.yml index b2487b6..f9c5dc0 100644 --- a/.github/workflows/wheel_build.yml +++ b/.github/workflows/wheel_build.yml @@ -40,7 +40,7 @@ jobs: - uses: actions/setup-python@v4 name: Install Python with: - python-version: '3.10' + python-version: '3.11' - name: Install cibuildwheel run: | @@ -57,6 +57,8 @@ jobs: CIBW_BEFORE_ALL_MACOS: brew install nasm && bash ci-utils/install_prereq_linux.sh && mkdir -p /tmp/argolid_bld && + brew uninstall --ignore-dependencies openssl || true && + sudo rm -rf /usr/local/include/openssl && cp -r local_install /tmp/argolid_bld CIBW_BEFORE_ALL_LINUX: curl -L https://www.nasm.us/pub/nasm/releasebuilds/2.15.05/nasm-2.15.05.tar.bz2 -o nasm-2.15.05.tar.bz2 && tar -xjf nasm-2.15.05.tar.bz2 && @@ -76,8 +78,11 @@ jobs: ON_GITHUB="TRUE" ARGOLID_DEP_DIR="/tmp/argolid_bld/local_install" CMAKE_ARGS="-DCMAKE_CXX_FLAGS=-Wno-missing-template-arg-list-after-template-kw -DTENSORSTORE_USE_SYSTEM_JPEG=ON -DTENSORSTORE_USE_SYSTEM_ZLIB=ON -DTENSORSTORE_USE_SYSTEM_PNG=ON" - CIBW_ENVIRONMENT_LINUX: LD_LIBRARY_PATH="/tmp/argolid_bld/local_install/lib:/tmp/argolid_bld/local_install/lib64:$LD_LIBRARY_PATH" ON_GITHUB="TRUE" ARGOLID_DEP_DIR="/tmp/argolid_bld/local_install" - CIBW_REPAIR_WHEEL_COMMAND_MACOS: DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-listdeps {wheel} && DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-wheel --require-archs {delocate_archs} -w {dest_dir} {wheel} + CIBW_ENVIRONMENT_LINUX: >- + LD_LIBRARY_PATH="/tmp/argolid_bld/local_install/lib:/tmp/argolid_bld/local_install/lib64:$LD_LIBRARY_PATH" + ON_GITHUB="TRUE" + ARGOLID_DEP_DIR="/tmp/argolid_bld/local_install" + CMAKE_ARGS="-DTENSORSTORE_USE_SYSTEM_JPEG=ON -DTENSORSTORE_USE_SYSTEM_ZLIB=ON -DTENSORSTORE_USE_SYSTEM_PNG=ON"CIBW_REPAIR_WHEEL_COMMAND_MACOS: DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-listdeps {wheel} && DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-wheel --require-archs {delocate_archs} -w {dest_dir} {wheel} CIBW_ENVIRONMENT_WINDOWS: PATH="$TEMP\\argolid\\bin;$PATH" ON_GITHUB="TRUE" ARGOLID_DEP_DIR="C:\\TEMP\\argolid_bld\\local_install" CMAKE_ARGS="-DCMAKE_GENERATOR=Ninja" CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: "delvewheel repair -w {dest_dir} {wheel}" CIBW_ARCHS: ${{ matrix.cibw_archs }} diff --git a/CMakeLists.txt b/CMakeLists.txt index ccc1201..34554cc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -40,8 +40,8 @@ include(FetchContent) FetchContent_Declare( tensorstore - URL "https://github.com/google/tensorstore/archive/refs/tags/v0.1.36.tar.gz" - URL_HASH SHA256=5857582b1b68e5a3f470d2ee8e9a7fa1ad6e6c7e0867c7c69e5a523ae00bc002 + URL "https://github.com/google/tensorstore/archive/refs/tags/v0.1.80.tar.gz" + URL_HASH SHA256=94866de34b6139d77d30e828a50f9e8df98e7dd68e848393470879aeb50ea7bf ) # Additional FetchContent_Declare calls as needed... diff --git a/ci-utils/install_prereq_linux.sh b/ci-utils/install_prereq_linux.sh index 2bc3afb..4b233bd 100755 --- a/ci-utils/install_prereq_linux.sh +++ b/ci-utils/install_prereq_linux.sh @@ -23,41 +23,47 @@ cmake -Dfilepattern_SHARED_LIB=ON -DCMAKE_PREFIX_PATH=../../$LOCAL_INSTALL_DIR - make install -j4 cd ../../ -curl -L https://github.com/pybind/pybind11/archive/refs/tags/v2.11.1.zip -o v2.11.1.zip -unzip v2.11.1.zip -cd pybind11-2.11.1 + +curl -L https://github.com/pybind/pybind11/archive/refs/tags/v2.12.0.zip -o v2.12.0.zip +unzip v2.12.0.zip +cd pybind11-2.12.0 mkdir build_man cd build_man cmake -DCMAKE_INSTALL_PREFIX=../../$LOCAL_INSTALL_DIR/ -DPYBIND11_TEST=OFF .. make install -j4 cd ../../ + +curl -L https://github.com/madler/zlib/releases/download/v1.3.1/zlib131.zip -o zlib131.zip +unzip zlib131.zip +cd zlib-1.3.1 +mkdir build_man +cd build_man +cmake -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_INSTALL_PREFIX=/usr/local .. +cmake --build . +cmake --build . --target install +cd ../../ + +curl -L https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/3.1.0.zip -o 3.1.0.zip +unzip 3.1.0.zip +cd libjpeg-turbo-3.1.0 +mkdir build_man +cd build_man +cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DENABLE_STATIC=FALSE -DCMAKE_BUILD_TYPE=Release .. if [[ "$OSTYPE" == "darwin"* ]]; then - curl -L https://github.com/madler/zlib/releases/download/v1.3.1/zlib131.zip -o zlib131.zip - unzip zlib131.zip - cd zlib-1.3.1 - mkdir build_man - cd build_man - cmake -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_INSTALL_PREFIX=/usr/local .. - cmake --build . - cmake --build . --target install - cd ../../ - - curl -L https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/3.1.0.zip -o 3.1.0.zip - unzip 3.1.0.zip - cd libjpeg-turbo-3.1.0 - mkdir build_man - cd build_man - cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DENABLE_STATIC=FALSE -DCMAKE_BUILD_TYPE=Release .. - sudo make install -j4 - cd ../../ - - curl -L https://github.com/glennrp/libpng/archive/refs/tags/v1.6.53.zip -o v1.6.53.zip - unzip v1.6.53.zip - cd libpng-1.6.53 - mkdir build_man - cd build_man - cmake -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_INSTALL_PREFIX=/usr/local .. - make install -j4 - cd ../../ + sudo make install -j4 +else + make install -j4 fi +cd ../../ +make install -j4 +cd ../../ + +curl -L https://github.com/glennrp/libpng/archive/refs/tags/v1.6.53.zip -o v1.6.53.zip +unzip v1.6.53.zip +cd libpng-1.6.53 +mkdir build_man +cd build_man +cmake -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_INSTALL_PREFIX=/usr/local .. +make install -j4 +cd ../../ diff --git a/setup.py b/setup.py index b06beee..f37bee7 100644 --- a/setup.py +++ b/setup.py @@ -77,11 +77,6 @@ def build_extension(self, ext): subprocess.check_call( ["cmake", ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env ) - if platform.system() == "Linux": - result = subprocess.call(["sed", "-i", r"s/^#ifdef __has_builtin$/#if defined(__has_builtin) \&\& defined(__clang__)/", "_deps/tensorstore-src/tensorstore/internal/type_traits.h"], - cwd=self.build_temp, env=env) - if result != 0: - print("--------------- TensorStore patch failed!") subprocess.check_call( ["cmake", "--build", "."] + build_args, cwd=self.build_temp @@ -109,5 +104,5 @@ def build_extension(self, ext): test_suite="tests", install_requires=["pydantic", "filepattern", "tensorstore", "bfio"], zip_safe=False, - python_requires=">=3.8", + python_requires=">=3.11", ) diff --git a/src/cpp/ts_driver/ometiff/driver.cc b/src/cpp/ts_driver/ometiff/driver.cc index 4e0df34..fd128fa 100644 --- a/src/cpp/ts_driver/ometiff/driver.cc +++ b/src/cpp/ts_driver/ometiff/driver.cc @@ -2,6 +2,7 @@ #include "metadata.h" #include "tensorstore/driver/driver.h" +#include "tensorstore/driver/driver_spec.h" #include "absl/status/status.h" #include "absl/strings/str_cat.h" #include "tensorstore/context.h" @@ -10,7 +11,11 @@ #include "tensorstore/driver/registry.h" #include "tensorstore/index.h" #include "tensorstore/index_space/index_transform_builder.h" +#include "tensorstore/index_space/transform_broadcastable_array.h" +#include "tensorstore/internal/async_write_array.h" #include "tensorstore/internal/cache/chunk_cache.h" +#include "tensorstore/internal/chunk_grid_specification.h" +#include "tensorstore/contiguous_layout.h" #include "tensorstore/internal/json_binding/json_binding.h" #include "tensorstore/internal/path.h" #include "tensorstore/kvstore/kvstore.h" @@ -19,6 +24,7 @@ #include "tensorstore/util/future.h" #include +#include #include #include @@ -86,8 +92,7 @@ class OmeTiffDriverSpec Future Open( - internal::OpenTransactionPtr transaction, - ReadWriteMode read_write_mode) const override; + internal::DriverOpenRequest request) const override; }; // we need OMETiff Metadata @@ -143,12 +148,17 @@ class DataCache : public internal_kvs_backed_chunk_driver::DataCache { using Base = internal_kvs_backed_chunk_driver::DataCache; public: - explicit DataCache(Initializer initializer, std::string key_prefix) - : Base(initializer, - GetChunkGridSpecification(*static_cast( - initializer.metadata.get()))), + explicit DataCache(Initializer&& initializer, std::string key_prefix) + : Base(std::move(initializer), + GetChunkGridSpecification( + *static_cast( + initializer.metadata.get()))), key_prefix_(std::move(key_prefix)) {} + const OmeTiffMetadata& metadata() const { + return *static_cast(initial_metadata().get()); + } + absl::Status ValidateMetadataCompatibility( const void* existing_metadata_ptr, const void* new_metadata_ptr) override { @@ -195,47 +205,70 @@ class DataCache : public internal_kvs_backed_chunk_driver::DataCache { static internal::ChunkGridSpecification GetChunkGridSpecification( const OmeTiffMetadata& metadata) { - SharedArray fill_value( - internal::AllocateAndConstructSharedElements(1, value_init, - metadata.dtype), - StridedLayout<>(metadata.chunk_layout.shape(), - GetConstantVector(metadata.rank))); - return internal::ChunkGridSpecification( - {internal::ChunkGridSpecification::Component(std::move(fill_value), - // Since all dimensions are - // resizable, just specify - // unbounded - // `component_bounds`. - Box<>(metadata.rank))}); + const DimensionIndex rank = metadata.rank; + + // Create fill value (zero-initialized) + auto fill_value = AllocateArray(span{}, c_order, value_init, + metadata.dtype); + + // Valid data bounds - unbounded since all dimensions are resizable + Box<> valid_data_bounds(rank); + + // Broadcast fill value to the valid bounds + auto chunk_fill_value = BroadcastArray(fill_value, valid_data_bounds).value(); + + // Cell chunk shape from metadata + std::vector cell_chunk_shape(metadata.chunk_layout.shape().begin(), + metadata.chunk_layout.shape().end()); + + // Chunked to cell dimensions mapping (identity for OmeTiff) + std::vector chunked_to_cell_dimensions(rank); + std::iota(chunked_to_cell_dimensions.begin(), + chunked_to_cell_dimensions.end(), static_cast(0)); + + // Create layout order buffer for C order (identity permutation) + DimensionIndex layout_order_buffer[kMaxRank]; + for (DimensionIndex i = 0; i < rank; ++i) { + layout_order_buffer[i] = i; + } + + // Build component list with AsyncWriteArray::Spec + internal::ChunkGridSpecification::ComponentList components; + components.emplace_back( + internal::AsyncWriteArray::Spec{std::move(chunk_fill_value), + std::move(valid_data_bounds), + ContiguousLayoutPermutation<>( + span(layout_order_buffer, rank))}, + std::move(cell_chunk_shape), chunked_to_cell_dimensions); + + return internal::ChunkGridSpecification{std::move(components)}; } - Result, 1>> DecodeChunk( - const void* metadata, span chunk_indices, + Result, 1>> DecodeChunk( + span chunk_indices, absl::Cord data) override { TENSORSTORE_ASSIGN_OR_RETURN( auto array, - internal_ometiff::DecodeChunk(*static_cast(metadata), - std::move(data))); - return absl::InlinedVector, 1>{ - std::move(array)}; + internal_ometiff::DecodeChunk(metadata(), std::move(data))); + return absl::InlinedVector, 1>{ + SharedArray(std::move(array))}; } Result EncodeChunk( - const void* metadata, span chunk_indices, - span> component_arrays) override { + span chunk_indices, + span> component_arrays) override { return absl::Cord(); } - std::string GetChunkStorageKey(const void* metadata_ptr, - span cell_indices) override { + std::string GetChunkStorageKey(span cell_indices) override { // OMETiff is always 5D. So need to add some check here - const auto& metadata = *static_cast(metadata_ptr); + const auto& md = metadata(); - size_t ifd = metadata.GetIfdIndex(cell_indices[2],cell_indices[1],cell_indices[0]); + size_t ifd = md.GetIfdIndex(cell_indices[2],cell_indices[1],cell_indices[0]); std::string key = StrCat(key_prefix_, "__TAG__/" ); - auto& chunk_shape = metadata.chunk_shape; + auto& chunk_shape = md.chunk_shape; // StrAppend(&key, cell_indices.empty() ? 0 : cell_indices[0]); StrAppend(&key, "_", cell_indices[3]*chunk_shape[3]); @@ -276,12 +309,12 @@ class DataCache : public internal_kvs_backed_chunk_driver::DataCache { return absl::OkStatus(); } - Result GetChunkLayout(const void* metadata_ptr, - std::size_t component_index) override { - const auto& metadata = *static_cast(metadata_ptr); + Result GetChunkLayoutFromMetadata(const void* metadata_ptr, + size_t component_index) override { + const auto& md = *static_cast(metadata_ptr); ChunkLayout chunk_layout; TENSORSTORE_RETURN_IF_ERROR(SetChunkLayoutFromMetadata( - metadata.rank, metadata.chunk_shape, chunk_layout)); + md.rank, md.chunk_shape, chunk_layout)); TENSORSTORE_RETURN_IF_ERROR(chunk_layout.Finalize()); return chunk_layout; } @@ -292,11 +325,16 @@ class DataCache : public internal_kvs_backed_chunk_driver::DataCache { std::string key_prefix_; }; -class OmeTiffDriver : public internal_kvs_backed_chunk_driver::RegisteredKvsDriver< - OmeTiffDriver, OmeTiffDriverSpec> { - using Base = - internal_kvs_backed_chunk_driver::RegisteredKvsDriver; +// Forward declaration for the mixin +class OmeTiffDriver; + +using OmeTiffDriverBase = internal_kvs_backed_chunk_driver::RegisteredKvsDriver< + OmeTiffDriver, OmeTiffDriverSpec, DataCache, + internal::ChunkCacheReadWriteDriverMixin< + OmeTiffDriver, internal_kvs_backed_chunk_driver::KvsChunkedDriverBase>>; + +class OmeTiffDriver : public OmeTiffDriverBase { + using Base = OmeTiffDriverBase; public: using Base::Base; @@ -333,7 +371,7 @@ class OmeTiffDriver::OpenState : public OmeTiffDriver::OpenStateBase { Result> Create( - const void* existing_metadata) override { + const void* existing_metadata, CreateOptions options) override { if (existing_metadata) { return absl::AlreadyExistsError(""); } @@ -345,8 +383,8 @@ class OmeTiffDriver::OpenState : public OmeTiffDriver::OpenStateBase { return metadata; } - std::unique_ptr GetDataCache( - DataCache::Initializer initializer) override { + std::unique_ptr GetDataCache( + internal_kvs_backed_chunk_driver::DataCacheInitializer&& initializer) override { return std::make_unique(std::move(initializer), spec().store.path); } @@ -364,9 +402,8 @@ class OmeTiffDriver::OpenState : public OmeTiffDriver::OpenStateBase { }; Future OmeTiffDriverSpec::Open( - internal::OpenTransactionPtr transaction, - ReadWriteMode read_write_mode) const { - return OmeTiffDriver::Open(std::move(transaction), this, read_write_mode); + internal::DriverOpenRequest request) const { + return OmeTiffDriver::Open(this, std::move(request)); } } // namespace diff --git a/src/cpp/ts_driver/ometiff/metadata.cc b/src/cpp/ts_driver/ometiff/metadata.cc index 266fb43..7cc07b8 100644 --- a/src/cpp/ts_driver/ometiff/metadata.cc +++ b/src/cpp/ts_driver/ometiff/metadata.cc @@ -18,7 +18,7 @@ #include "tensorstore/internal/json_binding/json_binding.h" #include "tensorstore/internal/json_binding/std_optional.h" #include "tensorstore/internal/json_metadata_matching.h" -#include "tensorstore/internal/type_traits.h" +#include "absl/meta/type_traits.h" #include "tensorstore/serialization/fwd.h" #include "tensorstore/serialization/json_bindable.h" @@ -51,7 +51,7 @@ absl::Status ValidateMetadata(OmeTiffMetadata& metadata) { constexpr auto MetadataJsonBinder = [](auto maybe_optional) { return [=](auto is_loading, const auto& options, auto* obj, auto* j) { - using T = internal::remove_cvref_t; + using T = absl::remove_cvref_t; DimensionIndex* rank = nullptr; if constexpr (is_loading) { rank = &obj->rank; diff --git a/src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc b/src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc index 576a2cb..53e5355 100644 --- a/src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc +++ b/src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc @@ -33,11 +33,13 @@ #include "tensorstore/internal/json_binding/bindable.h" #include "tensorstore/internal/json_binding/json_binding.h" #include "tensorstore/internal/metrics/counter.h" -#include "tensorstore/internal/os_error_code.h" +#include "tensorstore/internal/os/error_code.h" +#include "tensorstore/internal/os/file_descriptor.h" +#include "tensorstore/internal/os/file_info.h" +#include "tensorstore/internal/os/file_util.h" #include "tensorstore/internal/path.h" -#include "tensorstore/internal/type_traits.h" +#include "tensorstore/internal/uri_utils.h" #include "tensorstore/kvstore/byte_range.h" -#include "tensorstore/kvstore/file/unique_handle.h" #include "tensorstore/kvstore/file/util.h" #include "tensorstore/kvstore/generation.h" #include "tensorstore/kvstore/key_range.h" @@ -54,9 +56,6 @@ #include "tensorstore/util/status.h" #include "tensorstore/util/str_cat.h" -// Include these last to reduce impact of macros. -#include "tensorstore/kvstore/file/posix_file_util.h" -#include "tensorstore/kvstore/file/windows_file_util.h" namespace tensorstore { namespace { @@ -67,13 +66,15 @@ using ::tensorstore::internal::GetLastErrorCode; using ::tensorstore::internal::GetOsErrorStatusCode; using ::tensorstore::internal::OsErrorCode; using ::tensorstore::internal::StatusFromOsError; -using ::tensorstore::internal_file_util::FileDescriptor; -using ::tensorstore::internal_file_util::FileInfo; -using ::tensorstore::internal_file_util::GetFileInfo; using ::tensorstore::internal_file_util::IsKeyValid; -using ::tensorstore::internal_file_util::kLockSuffix; using ::tensorstore::internal_file_util::LongestDirectoryPrefix; -using ::tensorstore::internal_file_util::UniqueFileDescriptor; +using ::tensorstore::internal_os::kLockSuffix; +using ::tensorstore::internal_os::FileDescriptor; +using ::tensorstore::internal_os::FileInfo; +using ::tensorstore::internal_os::GetFileInfo; +using ::tensorstore::internal_os::OpenFileWrapper; +using ::tensorstore::internal_os::OpenFlags; +using ::tensorstore::internal_os::UniqueFileDescriptor; using ::tensorstore::kvstore::ReadResult; // auto& tiled_tiff_bytes_read = internal_metrics::Counter::New( @@ -94,9 +95,9 @@ absl::Status ValidateKey(std::string_view key) { // Encode in the generation fields that uniquely identify the file. StorageGeneration GetFileGeneration(const FileInfo& info) { - return StorageGeneration::FromValues(internal_file_util::GetDeviceId(info), - internal_file_util::GetFileId(info), - internal_file_util::GetMTime(info)); + return StorageGeneration::FromValues(info.GetDeviceId(), + info.GetFileId(), + absl::ToUnixNanos(info.GetMTime())); } /// Returns a absl::Status for the current errno value. The message is composed @@ -108,10 +109,10 @@ absl::Status StatusFromErrno(std::string_view a = {}, std::string_view b = {}, absl::Status VerifyRegularFile(FileDescriptor fd, FileInfo* info, const char* path) { - if (!internal_file_util::GetFileInfo(fd, info)) { - return StatusFromErrno("Error getting file information: ", path); - } - if (!internal_file_util::IsRegularFile(*info)) { + TENSORSTORE_RETURN_IF_ERROR(GetFileInfo(fd, info), + tensorstore::MaybeAnnotateStatus(_, + tensorstore::StrCat("Error getting file information: ", path))); + if (!info->IsRegularFile()) { return absl::FailedPreconditionError( tensorstore::StrCat("Not a regular file: ", path)); } @@ -121,19 +122,18 @@ absl::Status VerifyRegularFile(FileDescriptor fd, FileInfo* info, Result OpenValueFile(const char* path, StorageGeneration* generation, std::int64_t* size = nullptr) { - UniqueFileDescriptor fd = - internal_file_util::OpenExistingFileForReading(path); - if (!fd.valid()) { - auto error = GetLastErrorCode(); - if (GetOsErrorStatusCode(error) == absl::StatusCode::kNotFound) { + auto fd_result = OpenFileWrapper(path, OpenFlags::DefaultRead); + if (!fd_result.ok()) { + if (fd_result.status().code() == absl::StatusCode::kNotFound) { *generation = StorageGeneration::NoValue(); - return fd; + return UniqueFileDescriptor{}; } - return StatusFromOsError(error, "Error opening file: ", path); + return fd_result.status(); } + UniqueFileDescriptor fd = std::move(*fd_result); FileInfo info; TENSORSTORE_RETURN_IF_ERROR(VerifyRegularFile(fd.get(), &info, path)); - if (size) *size = internal_file_util::GetSize(info); + if (size) *size = info.GetSize(); *generation = GetFileGeneration(info); return fd; } @@ -210,9 +210,9 @@ struct ReadTask { read_result.state = ReadResult::kMissing; return read_result; } - if (read_result.stamp.generation == options.if_not_equal || - (!StorageGeneration::IsUnknown(options.if_equal) && - read_result.stamp.generation != options.if_equal)) { + if (read_result.stamp.generation == options.generation_conditions.if_not_equal || + (!StorageGeneration::IsUnknown(options.generation_conditions.if_equal) && + read_result.stamp.generation != options.generation_conditions.if_equal)) { return read_result; } @@ -334,6 +334,9 @@ struct ReadTask { } } } + // auto time2 = std::chrono::steady_clock::now(); + // std::chrono::duration elapsed_time = time2 - time1; + //std::cout<<"Time Reading Tiff=" << elapsed_time.count()<< std::endl; return read_result; } }; From 95c72f389b87ea84e959bc5ec5cc2ecfb8599e14 Mon Sep 17 00:00:00 2001 From: Sameeul Samee Date: Tue, 17 Feb 2026 08:47:58 -0500 Subject: [PATCH 2/4] Remove comment --- src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc b/src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc index 53e5355..12beb2d 100644 --- a/src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc +++ b/src/cpp/ts_driver/tiled_tiff/tiled_tiff_key_value_store.cc @@ -334,9 +334,7 @@ struct ReadTask { } } } - // auto time2 = std::chrono::steady_clock::now(); - // std::chrono::duration elapsed_time = time2 - time1; - //std::cout<<"Time Reading Tiff=" << elapsed_time.count()<< std::endl; + return read_result; } }; From 26201473d55fd12db9a7c8d8bf079c419651fa09 Mon Sep 17 00:00:00 2001 From: Sameeul Samee Date: Tue, 17 Feb 2026 08:55:33 -0500 Subject: [PATCH 3/4] Python version mod --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index f37bee7..896dc0a 100644 --- a/setup.py +++ b/setup.py @@ -104,5 +104,5 @@ def build_extension(self, ext): test_suite="tests", install_requires=["pydantic", "filepattern", "tensorstore", "bfio"], zip_safe=False, - python_requires=">=3.11", + python_requires=">=3.10", ) From b4b0e5a8b6ba2b391543cd497608b2732ee35608 Mon Sep 17 00:00:00 2001 From: Sameeul Samee Date: Wed, 18 Feb 2026 15:55:14 -0500 Subject: [PATCH 4/4] fix syntax --- .github/workflows/wheel_build.yml | 3 +- Untitled.ipynb | 142 ++++++++++++++++++++++++++++++ 2 files changed, 144 insertions(+), 1 deletion(-) create mode 100644 Untitled.ipynb diff --git a/.github/workflows/wheel_build.yml b/.github/workflows/wheel_build.yml index f9c5dc0..02c3138 100644 --- a/.github/workflows/wheel_build.yml +++ b/.github/workflows/wheel_build.yml @@ -82,7 +82,8 @@ jobs: LD_LIBRARY_PATH="/tmp/argolid_bld/local_install/lib:/tmp/argolid_bld/local_install/lib64:$LD_LIBRARY_PATH" ON_GITHUB="TRUE" ARGOLID_DEP_DIR="/tmp/argolid_bld/local_install" - CMAKE_ARGS="-DTENSORSTORE_USE_SYSTEM_JPEG=ON -DTENSORSTORE_USE_SYSTEM_ZLIB=ON -DTENSORSTORE_USE_SYSTEM_PNG=ON"CIBW_REPAIR_WHEEL_COMMAND_MACOS: DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-listdeps {wheel} && DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-wheel --require-archs {delocate_archs} -w {dest_dir} {wheel} + CMAKE_ARGS="-DTENSORSTORE_USE_SYSTEM_JPEG=ON -DTENSORSTORE_USE_SYSTEM_ZLIB=ON -DTENSORSTORE_USE_SYSTEM_PNG=ON" + CIBW_REPAIR_WHEEL_COMMAND_MACOS: DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-listdeps {wheel} && DYLD_LIBRARY_PATH=$REPAIR_LIBRARY_PATH delocate-wheel --require-archs {delocate_archs} -w {dest_dir} {wheel} CIBW_ENVIRONMENT_WINDOWS: PATH="$TEMP\\argolid\\bin;$PATH" ON_GITHUB="TRUE" ARGOLID_DEP_DIR="C:\\TEMP\\argolid_bld\\local_install" CMAKE_ARGS="-DCMAKE_GENERATOR=Ninja" CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: "delvewheel repair -w {dest_dir} {wheel}" CIBW_ARCHS: ${{ matrix.cibw_archs }} diff --git a/Untitled.ipynb b/Untitled.ipynb new file mode 100644 index 0000000..0962c4b --- /dev/null +++ b/Untitled.ipynb @@ -0,0 +1,142 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 21, + "id": "c51f1707-cf43-462f-b823-9c4c1efe3ea7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 1, 1, 22792, 13023)\n" + ] + } + ], + "source": [ + "import zarr\n", + "zarr_array = zarr.open_array(\"/home/samee/axle_data/nibib_download/mergedDeconXY_1009.ome.zarr/0/\")\n", + "print(zarr_array.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e28b825-c101-4f57-984c-e83d0caabc0d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "da8b2747-9828-4591-a607-f1236bfd99f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 100, 22792, 13023)\n" + ] + } + ], + "source": [ + "zarr_array_2 = zarr.open_array(\"/home/samee/axle_data/test_image_3.ome.zarr/0/\")\n", + "print(zarr_array_2.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "151a7d21-2fd8-4b20-be62-3e8fc2281046", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "429947404\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "image_data = zarr_array_2[0,9, 11000:11000+2048, 5000:5000+2048]\n", + "print(image_data.sum())\n", + "# Plot the grayscale image using matplotlib\n", + "plt.imshow(image_data, cmap=\"gray\")\n", + "plt.axis('off') # Turn off the axis\n", + "plt.title('Grayscale Image')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "58ac60be-0301-4793-ab9b-80e3fdc00b28", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "429947404\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "image_data = zarr_array[0,0,0, 11000:11000+2048, 5000:5000+2048]\n", + "print(image_data.sum())\n", + "# Plot the grayscale image using matplotlib\n", + "plt.imshow(image_data)\n", + "plt.axis('off') # Turn off the axis\n", + "plt.title('Grayscale Image')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}