diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..cc843b9 --- /dev/null +++ b/.clang-format @@ -0,0 +1,5 @@ +BasedOnStyle: Google +IndentWidth: 4 +IndentAccessModifiers: false +AccessModifierOffset: -4 +ColumnLimit: 100 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..16ef5c5 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,3 @@ +# GitHub syntax highlighting +pixi.lock linguist-language=YAML + diff --git a/.github/workflows/cpp-test.yml b/.github/workflows/cpp-test.yml new file mode 100644 index 0000000..d50a79a --- /dev/null +++ b/.github/workflows/cpp-test.yml @@ -0,0 +1,47 @@ +on: + push: + branches: + - "main" + pull_request: + +name: C++ + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + format: + name: Format and Lint + runs-on: ubuntu-latest + steps: + - name: Checkout source code + uses: actions/checkout@v4 + + - uses: prefix-dev/setup-pixi@v0.8.1 + with: + environments: format-cpp + + - name: Ensure code is properly formatted + run: | + pixi run format-cpp + git diff --exit-code + + test: + strategy: + fail-fast: false + matrix: + os: [ubuntu-20.04, macOS-latest, macOS-14, windows-latest ] + runs-on: ${{ matrix.os }} + needs: [ format ] + steps: + - name: Checkout source code + uses: actions/checkout@v4 + + - uses: prefix-dev/setup-pixi@v0.8.1 + with: + environments: test-cpp + + - name: Run the tests + run: | + pixi run test-cpp diff --git a/.github/workflows/rust-compile.yml b/.github/workflows/rust-compile.yml index f784556..3f8297d 100644 --- a/.github/workflows/rust-compile.yml +++ b/.github/workflows/rust-compile.yml @@ -43,7 +43,7 @@ jobs: run: cargo clippy build: - name: ubuntu-latest + name: Test runs-on: ubuntu-latest needs: [ format_and_lint ] steps: diff --git a/.gitignore b/.gitignore index fa43deb..3e44df4 100644 --- a/.gitignore +++ b/.gitignore @@ -18,3 +18,9 @@ Cargo.lock *.pdb **/.DS_Store + +build/ +# pixi environments +.pixi +*.egg-info + diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..6ed1871 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,34 @@ +cmake_minimum_required(VERSION 3.21) + +project(resolvo LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +include(FeatureSummary) + +option(RESOLVO_BUILD_TESTING "Build tests" OFF) +add_feature_info(RESOLVO_BUILD_TESTING RESOLVO_BUILD_TESTING "configure whether to build the test suite") +include(CTest) + +set(RESOLVO_IS_TOPLEVEL_BUILD TRUE) + +# Place all compiled examples into the same bin directory +# on Windows, where we'll also put the dll +if (WIN32) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/bin/debug) + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/bin/release) +elseif(APPLE) + # On macOS, the resolvo_cpp.dylib's install_name uses @rpath. CMake doesn't + # set BUILD_RPATH for imported targets though, so include the directory here + # by hand in the rpath used to build binaries in the build tree (such as our + # examples or tests). + set(CMAKE_BUILD_RPATH ${CMAKE_BINARY_DIR}/cpp) +endif() + +add_subdirectory(cpp/) + +feature_summary(WHAT ENABLED_FEATURES DESCRIPTION "Enabled features:") +feature_summary(WHAT DISABLED_FEATURES DESCRIPTION "Disabled features:") \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 09e4710..3809427 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,19 +1,31 @@ [workspace] -members = ["tools/solve-snapshot"] +members = ["cpp", "tools/*"] +resolver = "2" -[package] +[workspace.package] name = "resolvo" version = "0.6.1" authors = ["Adolfo Ochagavía ", "Bas Zalmstra ", "Tim de Jager "] -description = "Fast package resolver written in Rust (CDCL based SAT solving)" -keywords = ["dependency", "solver", "version"] -categories = ["algorithms"] homepage = "https://github.com/mamba-org/resolvo" repository = "https://github.com/mamba-org/resolvo" license = "BSD-3-Clause" edition = "2021" readme = "README.md" -resolver = "2" +keywords = ["dependency", "solver", "version"] +categories= ["algorithms"] + +[package] +name = "resolvo" +version.workspace = true +authors.workspace = true +description= "Fast package resolver written in Rust (CDCL based SAT solving)" +keywords.workspace = true +categories.workspace = true +homepage.workspace = true +repository.workspace = true +license.workspace = true +edition.workspace = true +readme.workspace = true [dependencies] ahash = "0.8.11" diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt new file mode 100644 index 0000000..9af3b77 --- /dev/null +++ b/cpp/CMakeLists.txt @@ -0,0 +1,86 @@ +cmake_minimum_required(VERSION 3.21) + +# Select C++ and C as languages, as Corrosion needs ${CMAKE_C_COMPILER} +# for linking +project(Resolvo LANGUAGES C CXX VERSION 0.1.0) + +# Add the Corrosion dependency (used to build Rust code) +include(FetchContent) +FetchContent_Declare( + Corrosion + GIT_REPOSITORY https://github.com/corrosion-rs/corrosion.git + GIT_TAG v0.4.9 +) +FetchContent_MakeAvailable(Corrosion) + +# Add the Corrosion CMake module path to the list of paths to search for modules +list(PREPEND CMAKE_MODULE_PATH ${Corrosion_SOURCE_DIR}/cmake) +find_package(Rust 1.75 REQUIRED MODULE) + +option(BUILD_SHARED_LIBS "Build Resolvo as shared library" ON) + +set(RESOLVO_LIBRARY_CARGO_FLAGS "" CACHE STRING + "Flags to pass to cargo when building the Resolvo runtime library") + +if(BUILD_SHARED_LIBS) + set(rustc_lib_type "cdylib") + set(resolvo_cpp_impl "resolvo_cpp-shared") + set(cmake_lib_type "SHARED") +else() + set(rustc_lib_type "staticlib") + set(resolvo_cpp_impl "resolvo_cpp-static") + set(cmake_lib_type "STATIC") +endif() + +corrosion_import_crate(MANIFEST_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Cargo.toml" + CRATES resolvo_cpp CRATE_TYPES bin ${rustc_lib_type}) + +add_library(Resolvo INTERFACE) +add_library(Resolvo::Resolvo ALIAS Resolvo) +target_link_libraries(Resolvo INTERFACE resolvo_cpp) + +set_property( + TARGET resolvo_cpp + APPEND + PROPERTY CORROSION_ENVIRONMENT_VARIABLES + "RESOLVO_GENERATED_INCLUDE_DIR=${CMAKE_CURRENT_BINARY_DIR}/generated_include/" +) + +file(GLOB api_headers RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/include/" + "${CMAKE_CURRENT_SOURCE_DIR}/include/*.h") + +foreach(header IN LISTS api_headers) + set_property(TARGET Resolvo APPEND PROPERTY PUBLIC_HEADER include/${header}) +endforeach() + +set(generated_headers + ${CMAKE_CURRENT_BINARY_DIR}/generated_include/resolvo_vector_internal.h + ${CMAKE_CURRENT_BINARY_DIR}/generated_include/resolvo_string_internal.h + ${CMAKE_CURRENT_BINARY_DIR}/generated_include/resolvo_internal.h +) + +foreach(header IN LISTS generated_headers) + set_property(TARGET Resolvo APPEND PROPERTY PUBLIC_HEADER ${header}) +endforeach() + +target_include_directories(Resolvo INTERFACE + $ + $ + $ +) + +export(TARGETS Resolvo resolvo_cpp + NAMESPACE Resolvo:: FILE "${CMAKE_BINARY_DIR}/lib/cmake/Resolvo/ResolvoTargets.cmake") +install(EXPORT ResolvoTargets NAMESPACE Resolvo:: DESTINATION lib/cmake/Resolvo) +install(TARGETS Resolvo resolvo_cpp + EXPORT ResolvoTargets LIBRARY DESTINATION lib PUBLIC_HEADER DESTINATION include/resolvo) + +install(FILES $ TYPE LIB) + +if(WIN32) + install(FILES $ TYPE LIB) +endif() + +if(RESOLVO_BUILD_TESTING) + add_subdirectory(tests) +endif() diff --git a/cpp/Cargo.toml b/cpp/Cargo.toml new file mode 100644 index 0000000..e8893e7 --- /dev/null +++ b/cpp/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "resolvo_cpp" +description = "Resolvo C++ integration" +version.workspace = true +authors.workspace = true +keywords.workspace = true +categories.workspace = true +homepage.workspace = true +repository.workspace = true +license.workspace = true +edition.workspace = true +readme.workspace = true +publish = false + +[lib] +crate-type = ["lib", "cdylib", "staticlib"] + +[dependencies] +resolvo = { path = "../" } + +[build-dependencies] +anyhow = "1" +cbindgen = "0.26.0" + diff --git a/cpp/build.rs b/cpp/build.rs new file mode 100644 index 0000000..452c5fd --- /dev/null +++ b/cpp/build.rs @@ -0,0 +1,92 @@ +use std::path::{Path, PathBuf}; + +use anyhow::Context; + +fn main() -> anyhow::Result<()> { + let manifest_dir = PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap()); + + println!("cargo:rerun-if-env-changed=RESOLVO_GENERATED_INCLUDE_DIR"); + let output_dir = std::env::var_os("RESOLVO_GENERATED_INCLUDE_DIR").unwrap_or_else(|| { + Path::new(&std::env::var_os("OUT_DIR").unwrap()) + .join("generated_include") + .into() + }); + let output_dir = Path::new(&output_dir); + + println!("cargo:GENERATED_INCLUDE_DIR={}", output_dir.display()); + + std::fs::create_dir_all(output_dir).context("Could not create the include directory")?; + + let mut default_config = cbindgen::Config::default(); + default_config.macro_expansion.bitflags = true; + default_config.pragma_once = true; + default_config.include_version = true; + default_config.namespaces = Some(vec!["resolvo".into(), "cbindgen_private".into()]); + default_config.line_length = 100; + default_config.tab_width = 4; + default_config.language = cbindgen::Language::Cxx; + default_config.cpp_compat = true; + default_config.documentation = true; + default_config.documentation_style = cbindgen::DocumentationStyle::Doxy; + default_config.structure.associated_constants_in_body = true; + default_config.constant.allow_constexpr = true; + default_config.export.exclude = vec!["Slice".into()]; + + cbindgen::Builder::new() + .with_config(default_config.clone()) + .with_src(manifest_dir.join("src/vector.rs")) + .generate() + .context("Unable to generate bindings for resolvo_vector_internal.h")? + .write_to_file(output_dir.join("resolvo_vector_internal.h")); + + let mut string_config = default_config.clone(); + string_config.export.exclude = vec!["String".into()]; + + cbindgen::Builder::new() + .with_config(string_config.clone()) + .with_src(manifest_dir.join("src/string.rs")) + .with_after_include("namespace resolvo { struct String; }") + .generate() + .context("Unable to generate bindings for resolvo_string_internal.h")? + .write_to_file(output_dir.join("resolvo_string_internal.h")); + + let mut config = default_config.clone(); + config.export.exclude.extend(vec![ + "Vector".into(), + "resolvo_vector_free".into(), + "resolvo_vector_allocate".into(), + "resolvo_vector_empty".into(), + "String".into(), + "resolvo_string_bytes".into(), + "resolvo_string_drop".into(), + "resolvo_string_clone".into(), + "resolvo_string_from_bytes".into(), + ]); + config.export.body.insert( + "Slice".to_owned(), + r" + const T &operator[](int i) const { return ptr[i]; } + /// Note: this doesn't initialize Slice properly, but we need to keep the struct as compatible with C + constexpr Slice() = default; + /// Rust uses a NonNull, so even empty slices shouldn't use nullptr + constexpr Slice(const T *ptr, uintptr_t len) : ptr(ptr ? const_cast(ptr) : reinterpret_cast(sizeof(T))), len(len) {}" + .to_owned(), + ); + + cbindgen::Builder::new() + .with_config(config.clone()) + .with_src(manifest_dir.join("src/lib.rs")) + .with_include("resolvo_slice.h") + .with_include("resolvo_vector.h") + .with_include("resolvo_string.h") + .generate() + .context("Unable to generate bindings for resolvo_internal.h")? + .write_to_file(output_dir.join("resolvo_internal.h")); + + println!("cargo:rerun-if-changed=src/lib.rs"); + println!("cargo:rerun-if-changed=src/slice.rs"); + println!("cargo:rerun-if-changed=src/string.rs"); + println!("cargo:rerun-if-changed=src/vector.rs"); + + Ok(()) +} diff --git a/cpp/include/resolvo.h b/cpp/include/resolvo.h new file mode 100644 index 0000000..6a41aa3 --- /dev/null +++ b/cpp/include/resolvo.h @@ -0,0 +1,37 @@ +#pragma once + +#include "resolvo_dependency_provider.h" +#include "resolvo_internal.h" + +namespace resolvo { + +/** + * Called to solve a package problem. + * + * If the solve was successful, an empty string is returned and selected solvable ids will be + * stored in `result`. If the solve was unsuccesfull an error describing the reason is returned and + * the result vector will be empty. + */ +inline String solve(DependencyProvider &provider, Slice requirements, + Slice constraints, Vector &result) { + cbindgen_private::DependencyProvider bridge{ + static_cast(&provider), + private_api::bridge_display_solvable, + private_api::bridge_display_solvable_name, + private_api::bridge_display_merged_solvables, + private_api::bridge_display_name, + private_api::bridge_display_version_set, + private_api::bridge_display_string, + private_api::bridge_version_set_name, + private_api::bridge_solvable_name, + private_api::bridge_get_candidates, + private_api::bridge_sort_candidates, + private_api::bridge_filter_candidates, + private_api::bridge_get_dependencies, + }; + + String error; + cbindgen_private::resolvo_solve(&bridge, requirements, constraints, &error, &result); + return error; +} +} // namespace resolvo diff --git a/cpp/include/resolvo_dependency_provider.h b/cpp/include/resolvo_dependency_provider.h new file mode 100644 index 0000000..5f56c9c --- /dev/null +++ b/cpp/include/resolvo_dependency_provider.h @@ -0,0 +1,152 @@ +#pragma once + +#include "resolvo_internal.h" +#include "resolvo_slice.h" +#include "resolvo_string.h" +#include "resolvo_vector.h" + +namespace resolvo { +using cbindgen_private::Candidates; +using cbindgen_private::Dependencies; +using cbindgen_private::ExcludedSolvable; +using cbindgen_private::NameId; +using cbindgen_private::SolvableId; +using cbindgen_private::StringId; +using cbindgen_private::VersionSetId; + +/** + * An interface that implements ecosystem specific logic. + */ +struct DependencyProvider { + /** + * Returns a user-friendly string representation of the specified solvable. + * + * When formatting the solvable, it should it include both the name of + * the package and any other identifying properties. + */ + virtual String display_solvable(SolvableId solvable) = 0; + + /** + * Returns a user-friendly string representation of the name of the + * specified solvable. + */ + virtual String display_solvable_name(SolvableId solvable) { + return display_name(solvable_name(solvable)); + } + + /** + * Returns a string representation of multiple solvables merged together. + * + * When formatting the solvables, both the name of the packages and any + * other identifying properties should be included. + */ + virtual String display_merged_solvables(Slice solvable) = 0; + + /** + * Returns an object that can be used to display the given name in a + * user-friendly way. + */ + virtual String display_name(NameId name) = 0; + + /** + * Returns a user-friendly string representation of the specified version + * set. + * + * The name of the package should *not* be included in the display. Where + * appropriate, this information is added. + */ + virtual String display_version_set(VersionSetId version_set) = 0; + + /** + * Returns the string representation of the specified string. + */ + virtual String display_string(StringId string) = 0; + + /** + * Returns the name of the package that the specified version set is + * associated with. + */ + virtual NameId version_set_name(VersionSetId version_set_id) = 0; + + /** + * Returns the name of the package for the given solvable. + */ + virtual NameId solvable_name(SolvableId solvable_id) = 0; + + /** + * Obtains a list of solvables that should be considered when a package + * with the given name is requested. + */ + virtual Candidates get_candidates(NameId package) = 0; + + /** + * Sort the specified solvables based on which solvable to try first. The + * solver will iteratively try to select the highest version. If a + * conflict is found with the highest version the next version is + * tried. This continues until a solution is found. + */ + virtual void sort_candidates(Slice solvables) = 0; + + /** + * Given a set of solvables, return the candidates that match the given + * version set or if `inverse` is true, the candidates that do *not* match + * the version set. + */ + virtual Vector filter_candidates(Slice candidates, + VersionSetId version_set_id, bool inverse) = 0; + + /** + * Returns the dependencies for the specified solvable. + */ + virtual Dependencies get_dependencies(SolvableId solvable) = 0; +}; + +namespace private_api { +extern "C" inline void bridge_display_solvable(void *data, SolvableId solvable, String *result) { + *result = reinterpret_cast(data)->display_solvable(solvable); +} +extern "C" inline void bridge_display_solvable_name(void *data, SolvableId solvable, + String *result) { + *result = reinterpret_cast(data)->display_solvable_name(solvable); +} +extern "C" inline void bridge_display_merged_solvables(void *data, Slice solvable, + String *result) { + *result = reinterpret_cast(data)->display_merged_solvables(solvable); +} +extern "C" inline void bridge_display_name(void *data, NameId name, String *result) { + *result = reinterpret_cast(data)->display_name(name); +} +extern "C" inline void bridge_display_version_set(void *data, VersionSetId version_set, + String *result) { + *result = reinterpret_cast(data)->display_version_set(version_set); +} +extern "C" inline void bridge_display_string(void *data, StringId string, String *result) { + *result = reinterpret_cast(data)->display_string(string); +} + +extern "C" inline NameId bridge_version_set_name(void *data, VersionSetId version_set_id) { + return reinterpret_cast(data)->version_set_name(version_set_id); +} +extern "C" inline NameId bridge_solvable_name(void *data, SolvableId solvable_id) { + return reinterpret_cast(data)->solvable_name(solvable_id); +} + +extern "C" inline void bridge_get_candidates(void *data, NameId package, Candidates *result) { + *result = reinterpret_cast(data)->get_candidates(package); +} +extern "C" inline void bridge_sort_candidates(void *data, Slice solvables) { + return reinterpret_cast(data)->sort_candidates(solvables); +} +extern "C" inline void bridge_filter_candidates(void *data, Slice candidates, + VersionSetId version_set_id, bool inverse, + Vector *result) { + *result = reinterpret_cast(data)->filter_candidates( + candidates, version_set_id, inverse); +} +extern "C" inline void bridge_get_dependencies(void *data, SolvableId solvable, + Dependencies *result) { + *result = reinterpret_cast(data)->get_dependencies(solvable); +} + +} // namespace private_api +} // namespace resolvo diff --git a/cpp/include/resolvo_pool.h b/cpp/include/resolvo_pool.h new file mode 100644 index 0000000..1f6452a --- /dev/null +++ b/cpp/include/resolvo_pool.h @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +namespace resolvo { +/** + * A Pool is an append only datastructure that associates a unique id with + * every element added. + * + * Id's are allocated in a monotonically increasing fashion, starting from 0. + */ +template +struct Pool { + Pool() = default; + ~Pool() = default; + + /** + * Adds the value to the pool and returns its associated id. If the + * value is already in the pool, returns the id associated with it. + */ + ID alloc(T value) { + if (auto element = value_to_id.find(value); element != value_to_id.end()) { + return element->second; + } + auto id = ID{static_cast(values.size())}; + values.push_back(value); + value_to_id.emplace(std::move(value), id); + return id; + } + + /** + * Returns the value associated with the given id. + */ + const T& operator[](ID id) const { return values[static_cast(id.id)]; } + +private: + std::deque values; + std::unordered_map value_to_id; +}; +} // namespace resolvo diff --git a/cpp/include/resolvo_slice.h b/cpp/include/resolvo_slice.h new file mode 100644 index 0000000..525bd59 --- /dev/null +++ b/cpp/include/resolvo_slice.h @@ -0,0 +1,45 @@ +#pragma once + +namespace resolvo { +template +struct Slice { + /// Note: this doesn't initialize Slice properly, but we need to keep the struct as compatible + /// with C + constexpr Slice() = default; + /// Rust uses a NonNull, so even empty slices shouldn't use nullptr + constexpr Slice(const T *ptr, uintptr_t len) + : ptr(ptr ? const_cast(ptr) : reinterpret_cast(sizeof(T))), len(len) {} + + /// Returns a const pointer to the first element of this slice. + const T *cbegin() const { return reinterpret_cast(ptr); } + + /// Returns a const pointer that points past the last element of this slice. + const T *cend() const { return ptr + len; } + + /// Returns a const pointer to the first element of this slice. + const T *begin() const { return cbegin(); } + + /// Returns a const pointer that points past the last element of this slice. + const T *end() const { return cend(); } + + /// Returns a pointer to the first element of this vector. + T *begin() { return reinterpret_cast(ptr); } + + /// Returns a pointer that points past the last element of this vector. The + /// pointer cannot be dereferenced, it can only be used for comparison. + T *end() { return ptr + len; } + + /// Returns the number of elements in this vector. + std::size_t size() const { return len; } + + /// Returns true if there are no elements on this vector; false otherwise. + bool empty() const { return len == 0; } + + /// This indexing operator returns a reference to the `index`th element of this vector. + T &operator[](std::size_t index) { return begin()[index]; } + +private: + T *ptr; + uintptr_t len; +}; +} // namespace resolvo diff --git a/cpp/include/resolvo_string.h b/cpp/include/resolvo_string.h new file mode 100644 index 0000000..9f2e53f --- /dev/null +++ b/cpp/include/resolvo_string.h @@ -0,0 +1,99 @@ +#pragma once + +#include + +#include "resolvo_string_internal.h" + +namespace resolvo { + +/// A string type that is used on both the Rust and C++ side. +/// +/// This type uses implicit data sharing to make it efficient to pass around +/// copied. When cloning, a reference to the data is cloned, not the data +/// itself. The data uses Copy-on-Write semantics, so the data is only cloned +/// when it is modified. +/// +/// The string data is stored as UTF8-encoded bytes, and it is always terminated +/// with a null character. +struct String { + /// Creates an empty default constructed string. + String() { cbindgen_private::resolvo_string_from_bytes(this, "", 0); } + + /// Creates a new String from a string view. The underlying string data is copied. + String(std::string_view s) { + cbindgen_private::resolvo_string_from_bytes(this, s.data(), s.size()); + } + + /// Creates a new String from the null-terminated string pointer `s`. The underlying + /// string data is copied. It is assumed that the string is UTF-8 encoded. + String(const char *s) : String(std::string_view(s)) {} + + /// Creates a new String from \a other. + String(const String &other) { cbindgen_private::resolvo_string_clone(this, &other); } + + /// Destroys this String and frees the memory if this is the last instance + /// referencing it. + ~String() { cbindgen_private::resolvo_string_drop(this); } + + /// Provides a view to the string data. The returned view is only valid as long as at + /// least this String exists. + operator std::string_view() const { return cbindgen_private::resolvo_string_bytes(this); } + /// Provides a raw pointer to the string data. The returned pointer is only valid as long as at + /// least this String exists. + auto data() const -> const char * { return cbindgen_private::resolvo_string_bytes(this); } + + /// Assigns \a other to this string and returns a reference to this string. + String &operator=(const String &other) { + cbindgen_private::resolvo_string_drop(this); + cbindgen_private::resolvo_string_clone(this, &other); + return *this; + } + + /// Assigns the string view \a s to this string and returns a reference to this string. + /// The underlying string data is copied. It is assumed that the string is UTF-8 encoded. + String &operator=(std::string_view s) { + cbindgen_private::resolvo_string_drop(this); + cbindgen_private::resolvo_string_from_bytes(this, s.data(), s.size()); + return *this; + } + + /// Assigns null-terminated string pointer s to this string and returns a reference + /// to this string. The underlying string data is copied. It is assumed that the string + /// is UTF-8 encoded. + String &operator=(const char *s) { return *this = std::string_view(s); } + + /// Move-assigns `other` to this String instance. + String &operator=(String &&other) { + std::swap(inner, other.inner); + return *this; + } + + /// Writes the string to the specified stream and returns a reference to the stream. + friend std::ostream &operator<<(std::ostream &stream, const String &string) { + return stream << std::string_view(string); + } + + /// Returns true if a is equal to b; otherwise returns false. + friend bool operator==(const String &a, const String &b) { + return std::string_view(a) == std::string_view(b); + } + /// Returns true if a is not equal to b; otherwise returns false. + friend bool operator!=(const String &a, const String &b) { + return std::string_view(a) != std::string_view(b); + } + +private: + void *inner; +}; + +} // namespace resolvo + +namespace std { +template <> +struct hash { + std::uint64_t operator()(const resolvo::String &str) const { + std::hash hash_fn; + return hash_fn(str); + } +}; +} // namespace std diff --git a/cpp/include/resolvo_vector.h b/cpp/include/resolvo_vector.h new file mode 100644 index 0000000..459e178 --- /dev/null +++ b/cpp/include/resolvo_vector.h @@ -0,0 +1,221 @@ +#pragma once + +#include +#include +#include +#include + +#include "resolvo_slice.h" +#include "resolvo_vector_internal.h" + +namespace resolvo { + +/// A simple vector implementation that uses reference counting to share data +/// between multiple instances. The vector is implemented as a contiguous array +/// of elements. The vector is copy-on-write, meaning that when a vector is +/// copied, the data is not copied. +template +struct Vector { + /// Constucts a new empty vector. + Vector() + : inner(const_cast
( + reinterpret_cast(cbindgen_private::resolvo_vector_empty()))) {} + + /// Creates a new vector that holds all the elements of the given std::initializer_list. + Vector(std::initializer_list args) : Vector(Vector::with_capacity(args.size())) { + auto new_data = reinterpret_cast(inner + 1); + auto input_it = args.begin(); + for (std::size_t i = 0; i < args.size(); ++i, ++input_it) { + new (new_data + i) T(*input_it); + inner->size++; + } + } + + /// Creates a vector of a given size, with default-constructed data. + explicit Vector(size_t size) : Vector(Vector::with_capacity(size)) { + auto new_data = reinterpret_cast(inner + 1); + for (std::size_t i = 0; i < size; ++i) { + new (new_data + i) T(); + inner->size++; + } + } + + /// Creates a vector of a given size, initialized with copies of `value`. + explicit Vector(size_t size, const T &value) : Vector(Vector::with_capacity(size)) { + auto new_data = reinterpret_cast(inner + 1); + for (std::size_t i = 0; i < size; ++i) { + new (new_data + i) T(value); + inner->size++; + } + } + + /// Constructs the container with the contents of the range `[first, last)`. + template + Vector(InputIt first, InputIt last) + : Vector(Vector::with_capacity(std::distance(first, last))) { + std::uninitialized_copy(first, last, begin()); + inner->size = inner->capacity; + } + + /// Creates a new vector by copying the contents of another vector. + /// Internally this function simplify increments the reference count of the + /// other vector. Therefore no actual data is copied. + Vector(const Vector &other) : inner(other.inner) { + if (inner->refcount > 0) { + ++inner->refcount; + } + } + + /// Destroys this vector. The underlying data is destroyed if no other + /// vector references it. + ~Vector() { drop(); } + + /// Provides a slice to the internal data. The returned Slice is only valid as long as at + /// least this Vector exists. + operator Slice() const { return Slice(begin(), size()); } + + /// Provides a slice to the internal data. The returned Slice is only valid as long as at + /// least this Vector exists. + operator Slice() { return Slice(begin(), size()); } + + /// Assigns the data of \a other to this vector and returns a reference to this vector. + Vector &operator=(const Vector &other) { + if (other.inner == inner) { + return *this; + } + drop(); + inner = other.inner; + if (inner->refcount > 0) { + ++inner->refcount; + } + return *this; + } + /// Move-assign's `other` to this vector and returns a reference to this vector. + Vector &operator=(Vector &&other) { + std::swap(inner, other.inner); + return *this; + } + + /// Returns a const pointer to the first element of this vector. + const T *cbegin() const { return reinterpret_cast(inner + 1); } + + /// Returns a const pointer that points past the last element of this vector. The + /// pointer cannot be dereferenced, it can only be used for comparison. + const T *cend() const { return cbegin() + inner->size; } + + /// Returns a const pointer to the first element of this vector. + const T *begin() const { return cbegin(); } + /// Returns a const pointer that points past the last element of this vector. The + /// pointer cannot be dereferenced, it can only be used for comparison. + const T *end() const { return cend(); } + + /// Returns a pointer to the first element of this vector. + T *begin() { + detach(inner->size); + return reinterpret_cast(inner + 1); + } + + /// Returns a pointer that points past the last element of this vector. The + /// pointer cannot be dereferenced, it can only be used for comparison. + T *end() { + detach(inner->size); + return begin() + inner->size; + } + + /// Returns the number of elements in this vector. + std::size_t size() const { return inner->size; } + + /// Returns true if there are no elements on this vector; false otherwise. + bool empty() const { return inner->size == 0; } + + /// This indexing operator returns a reference to the `index`th element of this vector. + T &operator[](std::size_t index) { return begin()[index]; } + + /// This indexing operator returns a const reference to the `index`th element of this vector. + const T &operator[](std::size_t index) const { return begin()[index]; } + + /// Returns a reference to the `index`th element of this vector. + const T &at(std::size_t index) const { return begin()[index]; } + + /// Appends the `value` as a new element to the end of this vector. + void push_back(const T &value) { + detach(inner->size + 1); + new (end()) T(value); + inner->size++; + } + + /// Moves the `value` as a new element to the end of this vector. + void push_back(T &&value) { + detach(inner->size + 1); + new (end()) T(std::move(value)); + inner->size++; + } + + /// Clears the vector and removes all elements. The capacity remains unaffected. + void clear() { + if (inner->refcount != 1) { + *this = Vector(); + } else { + auto b = cbegin(), e = cend(); + inner->size = 0; + for (auto it = b; it < e; ++it) { + it->~T(); + } + } + } + + /// Returns true if the vector `a` has the same number of elements as `b` + /// and all the elements also compare equal; false otherwise. + friend bool operator==(const Vector &a, const Vector &b) { + if (a.size() != b.size()) return false; + return std::equal(a.cbegin(), a.cend(), b.cbegin()); + } + + /// Returns the current allocated capacity of this vector. + std::size_t capacity() const { return inner->capacity; } + +private: + void detach(std::size_t expected_capacity) { + if (inner->refcount == 1 && expected_capacity <= inner->capacity) { + return; + } + auto new_array = Vector::with_capacity(expected_capacity); + auto old_data = reinterpret_cast(inner + 1); + auto new_data = reinterpret_cast(new_array.inner + 1); + for (std::size_t i = 0; i < inner->size; ++i) { + new (new_data + i) T(old_data[i]); + new_array.inner->size++; + } + *this = std::move(new_array); + } + + void drop() { + if (inner->refcount > 0 && (--inner->refcount) == 0) { + auto b = cbegin(), e = cend(); + for (auto it = b; it < e; ++it) { + it->~T(); + } + cbindgen_private::resolvo_vector_free(reinterpret_cast(inner), + sizeof(Header) + inner->capacity * sizeof(T), + alignof(Header)); + } + } + + static Vector with_capacity(std::size_t capacity) { + auto mem = cbindgen_private::resolvo_vector_allocate(sizeof(Header) + capacity * sizeof(T), + alignof(Header)); + return Vector(new (mem) Header{{1}, 0, capacity}); + } + + struct Header { + std::atomic refcount; + std::size_t size; + std::size_t capacity; + }; + static_assert(alignof(T) <= alignof(Header), + "Not yet supported because we would need to add padding"); + Header *inner; + explicit Vector(Header *inner) : inner(inner) {} +}; + +} // namespace resolvo diff --git a/cpp/src/lib.rs b/cpp/src/lib.rs new file mode 100644 index 0000000..f8bd5c6 --- /dev/null +++ b/cpp/src/lib.rs @@ -0,0 +1,476 @@ +mod slice; +mod string; +mod vector; + +use std::{ffi::c_void, fmt::Display, ptr::NonNull}; + +use resolvo::{KnownDependencies, SolverCache}; + +use crate::{slice::Slice, string::String, vector::Vector}; + +/// A unique identifier for a single solvable or candidate of a package. These ids should not be +/// random but rather monotonic increasing. Although it is fine to have gaps, resolvo will +/// allocate some memory based on the maximum id. +/// cbindgen:derive-eq +/// cbindgen:derive-neq +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SolvableId { + id: u32, +} + +impl From for SolvableId { + fn from(id: resolvo::SolvableId) -> Self { + Self { id: id.0 } + } +} + +impl From for resolvo::SolvableId { + fn from(id: SolvableId) -> Self { + Self(id.id) + } +} + +/// A unique identifier for a single version set. A version set describes a +/// set of versions. +/// cbindgen:derive-eq +/// cbindgen:derive-neq +#[repr(C)] +#[derive(Copy, Clone)] +pub struct VersionSetId { + id: u32, +} + +impl From for VersionSetId { + fn from(id: resolvo::VersionSetId) -> Self { + Self { id: id.0 } + } +} + +impl From for resolvo::VersionSetId { + fn from(id: VersionSetId) -> Self { + Self(id.id) + } +} + +/// A unique identifier for a single package name. Resolvo will only select +/// one candidate for each unique name. +/// cbindgen:derive-eq +/// cbindgen:derive-neq +#[repr(C)] +#[derive(Copy, Clone)] +pub struct NameId { + id: u32, +} + +impl From for NameId { + fn from(id: resolvo::NameId) -> Self { + Self { id: id.0 } + } +} + +impl From for resolvo::NameId { + fn from(id: NameId) -> Self { + Self(id.id) + } +} + +/// The string id is a unique identifier for a string. +/// cbindgen:derive-eq +/// cbindgen:derive-neq +#[repr(C)] +#[derive(Copy, Clone)] +pub struct StringId { + id: u32, +} + +impl From for StringId { + fn from(id: resolvo::StringId) -> Self { + Self { id: id.0 } + } +} + +impl From for resolvo::StringId { + fn from(id: StringId) -> Self { + Self(id.id) + } +} + +#[derive(Default)] +#[repr(C)] +pub struct Dependencies { + /// A pointer to the first element of a list of requirements. Requirements + /// defines which packages should be installed alongside the depending + /// package and the constraints applied to the package. + pub requirements: Vector, + + /// Defines additional constraints on packages that may or may not be part + /// of the solution. Different from `requirements`, packages in this set + /// are not necessarily included in the solution. Only when one or more + /// packages list the package in their `requirements` is the + /// package also added to the solution. + /// + /// This is often useful to use for optional dependencies. + pub constrains: Vector, +} + +#[repr(C)] +pub struct ExcludedSolvable { + /// The id of the solvable that is excluded from the solver. + pub solvable: SolvableId, + + /// A string that provides more information about why the solvable is + /// excluded (e.g. an error message). + pub reason: StringId, +} + +#[repr(C)] +pub struct Candidates { + /// A list of all solvables for the package. + pub candidates: Vector, + + /// Optionally a pointer to the id of the solvable that is favored over + /// other solvables. The solver will first attempt to solve for the + /// specified solvable but will fall back to other candidates if no solution + /// could be found otherwise. + /// + /// The same behavior can be achieved by sorting this candidate to the top + /// using the [`resolvo::DependencyProvider::sort_candidates`] function but + /// using this method provides better error messages to the user. + pub favored: *const SolvableId, + + /// If specified this is the Id of the only solvable that can be selected. + /// Although it would also be possible to simply return a single + /// candidate using this field provides better error messages to the + /// user. + pub locked: *const SolvableId, + + /// A hint to the solver that the dependencies of some of the solvables are + /// also directly available. This allows the solver to request the + /// dependencies of these solvables immediately. Having the dependency + /// information available might make the solver much faster because it + /// has more information available up-front which provides the solver with a + /// more complete picture of the entire problem space. However, it might + /// also be the case that the solver doesnt actually need this + /// information to form a solution. In general though, if the + /// dependencies can easily be provided one should provide them up-front. + pub hint_dependencies_available: Vector, + + /// A list of solvables that are available but have been excluded from the + /// solver. For example, a package might be excluded from the solver + /// because it is not compatible with the runtime. The solver will not + /// consider these solvables when forming a solution but will use + /// them in the error message if no solution could be found. + pub excluded: Vector, +} + +impl Default for Candidates { + fn default() -> Self { + Self { + candidates: Vector::default(), + favored: std::ptr::null(), + locked: std::ptr::null(), + hint_dependencies_available: Vector::default(), + excluded: Vector::default(), + } + } +} + +/// The dependency provider is a struct that is passed to the solver which +/// implements the ecosystem specific logic to resolve dependencies. +#[repr(C)] +pub struct DependencyProvider { + /// The data pointer is a pointer that is passed to each of the functions. + pub data: *mut c_void, + + /// Returns a user-friendly string representation of the specified solvable. + /// + /// When formatting the solvable, it should it include both the name of + /// the package and any other identifying properties. + pub display_solvable: + unsafe extern "C" fn(data: *mut c_void, solvable: SolvableId, result: NonNull), + + /// Returns a user-friendly string representation of the name of the + /// specified solvable. + pub display_solvable_name: + unsafe extern "C" fn(data: *mut c_void, solvable: SolvableId, result: NonNull), + + /// Returns a string representation of multiple solvables merged together. + /// + /// When formatting the solvables, both the name of the packages and any + /// other identifying properties should be included. + pub display_merged_solvables: unsafe extern "C" fn( + data: *mut c_void, + solvable: Slice, + result: NonNull, + ), + + /// Returns an object that can be used to display the given name in a + /// user-friendly way. + pub display_name: + unsafe extern "C" fn(data: *mut c_void, name: NameId, result: NonNull), + + /// Returns a user-friendly string representation of the specified version + /// set. + /// + /// The name of the package should *not* be included in the display. Where + /// appropriate, this information is added. + pub display_version_set: + unsafe extern "C" fn(data: *mut c_void, version_set: VersionSetId, result: NonNull), + + /// Returns the string representation of the specified string. + pub display_string: + unsafe extern "C" fn(data: *mut c_void, string: StringId, result: NonNull), + + /// Returns the name of the package that the specified version set is + /// associated with. + pub version_set_name: + unsafe extern "C" fn(data: *mut c_void, version_set_id: VersionSetId) -> NameId, + + /// Returns the name of the package for the given solvable. + pub solvable_name: unsafe extern "C" fn(data: *mut c_void, solvable_id: SolvableId) -> NameId, + + /// Obtains a list of solvables that should be considered when a package + /// with the given name is requested. + pub get_candidates: + unsafe extern "C" fn(data: *mut c_void, package: NameId, candidates: NonNull), + + /// Sort the specified solvables based on which solvable to try first. The + /// solver will iteratively try to select the highest version. If a + /// conflict is found with the highest version the next version is + /// tried. This continues until a solution is found. + pub sort_candidates: unsafe extern "C" fn(data: *mut c_void, solvables: Slice), + + /// Given a set of solvables, return the candidates that match the given + /// version set or if `inverse` is true, the candidates that do *not* match + /// the version set. + pub filter_candidates: unsafe extern "C" fn( + data: *mut c_void, + candidates: Slice, + version_set_id: VersionSetId, + inverse: bool, + filtered: NonNull>, + ), + + /// Returns the dependencies for the specified solvable. + pub get_dependencies: unsafe extern "C" fn( + data: *mut c_void, + solvable: SolvableId, + dependencies: NonNull, + ), +} + +impl<'d> resolvo::Interner for &'d DependencyProvider { + fn display_solvable(&self, solvable: resolvo::SolvableId) -> impl Display + '_ { + let mut result = String::default(); + unsafe { (self.display_solvable)(self.data, solvable.into(), NonNull::from(&mut result)) } + result + } + + fn display_solvable_name(&self, solvable: resolvo::SolvableId) -> impl Display + '_ { + let mut result = String::default(); + unsafe { + (self.display_solvable_name)(self.data, solvable.into(), NonNull::from(&mut result)) + } + result + } + + fn display_merged_solvables(&self, solvables: &[resolvo::SolvableId]) -> impl Display + '_ { + let mut result = String::default(); + unsafe { + (self.display_merged_solvables)( + self.data, + Slice::from_slice(std::mem::transmute(solvables)), + NonNull::from(&mut result), + ) + } + result + } + + fn display_name(&self, name: resolvo::NameId) -> impl Display + '_ { + let mut result = String::default(); + unsafe { (self.display_name)(self.data, name.into(), NonNull::from(&mut result)) } + result + } + + fn display_version_set(&self, version_set: resolvo::VersionSetId) -> impl Display + '_ { + let mut result = String::default(); + unsafe { + (self.display_version_set)(self.data, version_set.into(), NonNull::from(&mut result)) + } + result + } + + fn display_string(&self, string_id: resolvo::StringId) -> impl Display + '_ { + let mut result = String::default(); + unsafe { (self.display_string)(self.data, string_id.into(), NonNull::from(&mut result)) } + result + } + + fn version_set_name(&self, version_set: resolvo::VersionSetId) -> resolvo::NameId { + unsafe { (self.version_set_name)(self.data, version_set.into()) }.into() + } + + fn solvable_name(&self, solvable: resolvo::SolvableId) -> resolvo::NameId { + unsafe { (self.solvable_name)(self.data, solvable.into()) }.into() + } +} + +impl<'d> resolvo::DependencyProvider for &'d DependencyProvider { + async fn filter_candidates( + &self, + candidates: &[resolvo::SolvableId], + version_set: resolvo::VersionSetId, + inverse: bool, + ) -> Vec { + let mut result = Vector::default(); + unsafe { + (self.filter_candidates)( + self.data, + Slice::from_slice(std::mem::transmute(candidates)), + version_set.into(), + inverse, + NonNull::from(&mut result), + ) + }; + result.into_iter().map(Into::into).collect() + } + + async fn get_candidates(&self, name: resolvo::NameId) -> Option { + let mut candidates = Candidates { + candidates: Vector::default(), + favored: std::ptr::null(), + locked: std::ptr::null(), + hint_dependencies_available: Vector::default(), + excluded: Vector::default(), + }; + unsafe { (self.get_candidates)(self.data, name.into(), NonNull::from(&mut candidates)) }; + + unsafe { + Some(resolvo::Candidates { + candidates: candidates.candidates.into_iter().map(Into::into).collect(), + favored: candidates.favored.as_ref().copied().map(Into::into), + locked: candidates.locked.as_ref().copied().map(Into::into), + hint_dependencies_available: candidates + .hint_dependencies_available + .into_iter() + .map(Into::into) + .collect(), + excluded: candidates + .excluded + .into_iter() + .map(|excluded| (excluded.solvable.into(), excluded.reason.into())) + .collect(), + }) + } + } + + async fn sort_candidates( + &self, + _solver: &SolverCache, + solvables: &mut [resolvo::SolvableId], + ) { + unsafe { + (self.sort_candidates)(self.data, Slice::from_slice(std::mem::transmute(solvables))) + } + } + + async fn get_dependencies(&self, solvable: resolvo::SolvableId) -> resolvo::Dependencies { + let mut dependencies = Dependencies::default(); + unsafe { + (self.get_dependencies)(self.data, solvable.into(), NonNull::from(&mut dependencies)) + }; + + resolvo::Dependencies::Known(KnownDependencies { + requirements: dependencies + .requirements + .into_iter() + .map(Into::into) + .collect(), + constrains: dependencies + .constrains + .into_iter() + .map(Into::into) + .collect(), + }) + } +} + +#[no_mangle] +#[allow(unused)] +pub extern "C" fn resolvo_solve( + provider: &DependencyProvider, + requirements: Slice, + constraints: Slice, + error: &mut String, + result: &mut Vector, +) -> bool { + let requirements = requirements + .into_iter() + .copied() + .map(Into::into) + .collect::>(); + let constraints = constraints + .into_iter() + .copied() + .map(Into::into) + .collect::>(); + + let mut solver = resolvo::Solver::new(provider); + match solver.solve(requirements, constraints) { + Ok(solution) => { + *result = solution.into_iter().map(Into::into).collect(); + true + } + Err(resolvo::UnsolvableOrCancelled::Unsolvable(problem)) => { + *error = problem.display_user_friendly(&solver).to_string().into(); + false + } + Err(resolvo::UnsolvableOrCancelled::Cancelled(cancelled)) => { + *error = String::from("cancelled"); + false + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_memory_layout_compatiblity() { + assert_eq!( + std::mem::size_of::(), + std::mem::size_of::() + ); + assert_eq!( + std::mem::size_of::(), + std::mem::size_of::() + ); + assert_eq!( + std::mem::size_of::(), + std::mem::size_of::() + ); + assert_eq!( + std::mem::size_of::(), + std::mem::size_of::() + ); + + assert_eq!( + std::mem::align_of::(), + std::mem::align_of::() + ); + assert_eq!( + std::mem::align_of::(), + std::mem::align_of::() + ); + assert_eq!( + std::mem::align_of::(), + std::mem::align_of::() + ); + assert_eq!( + std::mem::align_of::(), + std::mem::align_of::() + ); + } +} diff --git a/cpp/src/slice.rs b/cpp/src/slice.rs new file mode 100644 index 0000000..0662a75 --- /dev/null +++ b/cpp/src/slice.rs @@ -0,0 +1,68 @@ +use std::{fmt::Debug, marker::PhantomData, ptr::NonNull}; + +#[repr(C)] +#[derive(PartialEq)] +pub struct Slice<'a, T> { + /// Invariant, this is a valid slice of len `len` + ptr: NonNull, + len: usize, + phantom: PhantomData<&'a [T]>, +} + +impl<'a, T: Debug> Debug for Slice<'a, T> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + self.as_slice().fmt(f) + } +} + +// Need to implement manually otherwise it is not implemented if T do not +// implement Copy / Clone +impl<'a, T> Copy for Slice<'a, T> {} + +impl<'a, T> Clone for Slice<'a, T> { + fn clone(&self) -> Self { + *self + } +} + +impl<'a, T> Slice<'a, T> { + /// Return a slice + pub fn as_slice(self) -> &'a [T] { + // Safety: it ptr is supposed to be a valid slice of given length + unsafe { core::slice::from_raw_parts(self.ptr.as_ptr(), self.len) } + } + + /// Create from a native slice + pub const fn from_slice(slice: &'a [T]) -> Self { + Slice { + // Safety: a slice is never null + ptr: unsafe { NonNull::new_unchecked(slice.as_ptr() as *mut T) }, + len: slice.len(), + phantom: PhantomData, + } + } +} + +impl<'a, T> From<&'a [T]> for Slice<'a, T> { + fn from(slice: &'a [T]) -> Self { + Self::from_slice(slice) + } +} + +impl<'a, T> core::ops::Deref for Slice<'a, T> { + type Target = [T]; + fn deref(&self) -> &[T] { + self.as_slice() + } +} + +impl<'a, T> Default for Slice<'a, T> { + fn default() -> Self { + Self::from_slice(&[]) + } +} + +/// Safety: Slice is the same as a rust slice, and a slice of Sync T is Sync +unsafe impl Sync for Slice<'_, T> {} +/// Safety: Slice is the same as a rust slice, and a slice of Send T is Sync +unsafe impl Send for Slice<'_, T> {} diff --git a/cpp/src/string.rs b/cpp/src/string.rs new file mode 100644 index 0000000..2d452f1 --- /dev/null +++ b/cpp/src/string.rs @@ -0,0 +1,134 @@ +use std::{ + fmt::{Debug, Display}, + ops::Deref, +}; + +use crate::vector::Vector; + +/// A string type that is used on both the Rust and C++ side. +/// +/// This type uses implicit data sharing to make it efficient to pass around +/// copied. When cloning, a reference to the data is cloned, not the data +/// itself. The data uses Copy-on-Write semantics, so the data is only cloned +/// when it is modified. +/// +/// The string data is stored as UTF8-encoded bytes, and it is always terminated +/// with a null character. +#[derive(Clone, Default)] +#[repr(C)] +pub struct String { + inner: Vector, +} + +impl String { + /// Returns a pointer to the underlying data. + pub fn as_ptr(&self) -> *const u8 { + self.inner.as_ptr() + } + + /// Returns the size of the string, in bytes. This excludes the terminating + /// null character. + pub fn len(&self) -> usize { + self.inner.len().saturating_sub(1) + } + + /// Returns true if the String is empty + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Returns a slice to the string + pub fn as_str(&self) -> &str { + // Safety: self.as_ptr is a pointer from the inner which has utf-8 + unsafe { + core::str::from_utf8_unchecked(core::slice::from_raw_parts(self.as_ptr(), self.len())) + } + } +} + +impl Deref for String { + type Target = str; + fn deref(&self) -> &Self::Target { + self.as_str() + } +} + +impl From<&str> for String { + fn from(value: &str) -> Self { + String { + inner: Vector::from_iter(value.as_bytes().iter().cloned().chain(core::iter::once(0))), + } + } +} + +impl From for String { + fn from(s: std::string::String) -> Self { + s.as_str().into() + } +} + +impl From<&std::string::String> for String { + fn from(s: &std::string::String) -> Self { + s.as_str().into() + } +} + +impl Debug for String { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{:?}", self.as_str()) + } +} + +impl Display for String { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{}", self.as_str()) + } +} + +impl AsRef for String { + #[inline] + fn as_ref(&self) -> &str { + self.as_str() + } +} + +/// for cbindgen. +#[allow(non_camel_case_types)] +type c_char = u8; + +#[no_mangle] +/// Returns a nul-terminated pointer for this string. +/// The returned value is owned by the string, and should not be used after any +/// mutable function have been called on the string, and must not be freed. +pub extern "C" fn resolvo_string_bytes(ss: &String) -> *const c_char { + if ss.is_empty() { + "\0".as_ptr() + } else { + ss.as_ptr() + } +} + +#[no_mangle] +/// Destroy the shared string +pub unsafe extern "C" fn resolvo_string_drop(ss: *const String) { + core::ptr::read(ss); +} + +#[no_mangle] +/// Increment the reference count of the string. +/// The resulting structure must be passed to resolvo_string_drop +pub unsafe extern "C" fn resolvo_string_clone(out: *mut String, ss: &String) { + core::ptr::write(out, ss.clone()) +} + +#[no_mangle] +/// Safety: bytes must be a valid utf-8 string of size len without null inside. +/// The resulting structure must be passed to resolvo_string_drop +pub unsafe extern "C" fn resolvo_string_from_bytes( + out: *mut String, + bytes: *const c_char, + len: usize, +) { + let str = core::str::from_utf8(core::slice::from_raw_parts(bytes, len)).unwrap(); + core::ptr::write(out, String::from(str)); +} diff --git a/cpp/src/vector.rs b/cpp/src/vector.rs new file mode 100644 index 0000000..e7f4cc3 --- /dev/null +++ b/cpp/src/vector.rs @@ -0,0 +1,439 @@ +use std::{fmt::Debug, mem::MaybeUninit, ops::Deref, ptr::NonNull, sync::atomic}; + +#[repr(C)] +struct VectorHeader { + refcount: atomic::AtomicIsize, + size: usize, + capacity: usize, +} + +#[repr(C)] +struct VectorInner { + header: VectorHeader, + data: MaybeUninit, +} + +#[repr(C)] +pub struct Vector { + inner: NonNull>, +} + +// Safety: We use atomic reference counting, and if T is Send, we can send the +// vector to another thread +unsafe impl Send for Vector {} + +impl Drop for Vector { + fn drop(&mut self) { + unsafe { + if self + .inner + .cast::() + .as_ref() + .refcount + .load(atomic::Ordering::Relaxed) + < 0 + { + return; + } + + if self + .inner + .as_ref() + .header + .refcount + .fetch_sub(1, atomic::Ordering::SeqCst) + == 1 + { + drop_inner(self.inner) + } + } + } +} + +impl Clone for Vector { + fn clone(&self) -> Self { + unsafe { + if self + .inner + .cast::() + .as_ref() + .refcount + .load(atomic::Ordering::Relaxed) + > 0 + { + self.inner + .as_ref() + .header + .refcount + .fetch_add(1, atomic::Ordering::SeqCst); + } + Vector { inner: self.inner } + } + } +} + +impl Vector { + /// Create a new empty array with a pre-allocated capacity in number of + /// items + pub fn with_capacity(capacity: usize) -> Self { + Self { + inner: alloc_with_capacity(capacity), + } + } + + /// Returns a pointer to the first element of the array. + pub fn as_ptr(&self) -> *const T { + unsafe { self.inner.as_ref().data.as_ptr() } + } + + /// Returns the number of elements in the array + pub fn len(&self) -> usize { + unsafe { self.inner.cast::().as_ref().size } + } + + /// Returns true if the Vector is empty + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Return a slice to the array + pub fn as_slice(&self) -> &[T] { + if self.is_empty() { + &[] + } else { + // Safety: When len > 0, we know that the pointer holds an array of + // the size of len + unsafe { core::slice::from_raw_parts(self.as_ptr(), self.len()) } + } + } + + /// Returns the number of elements the vector can hold without reallocating, + /// when not shared + fn capacity(&self) -> usize { + unsafe { self.inner.cast::().as_ref().capacity } + } +} + +impl Vector { + /// Ensure that the reference count is 1 so the array can be changed. + /// If that's not the case, the array will be cloned + fn detach(&mut self, new_capacity: usize) { + let is_shared = unsafe { + self.inner + .as_ref() + .header + .refcount + .load(atomic::Ordering::Relaxed) + } != 1; + if !is_shared && new_capacity <= self.capacity() { + return; + } + let mut new_array = Vector::with_capacity(new_capacity); + core::mem::swap(&mut self.inner, &mut new_array.inner); + let mut size = 0; + for x in new_array.into_iter() { + assert_ne!(size, new_capacity); + unsafe { + core::ptr::write(self.inner.as_mut().data.as_mut_ptr().add(size), x); + size += 1; + self.inner.as_mut().header.size = size; + } + if size == new_capacity { + break; + } + } + } + + /// Adds an element to the array. If the array was shared, this will make a + /// copy of the array. + pub fn push(&mut self, value: T) { + self.detach(determine_capacity_for_growth( + self.capacity(), + self.len() + 1, + core::mem::size_of::(), + )); + unsafe { + core::ptr::write( + self.inner + .as_mut() + .data + .as_mut_ptr() + .add(self.inner.as_mut().header.size), + value, + ); + self.inner.as_mut().header.size += 1; + } + } +} + +impl Deref for Vector { + type Target = [T]; + fn deref(&self) -> &Self::Target { + self.as_slice() + } +} + +impl FromIterator for Vector { + fn from_iter>(iter: I) -> Self { + let mut iter = iter.into_iter(); + let mut capacity = iter.size_hint().0; + let mut result = Self::with_capacity(capacity); + let mut size = 0; + while let Some(x) = iter.next() { + if size >= capacity { + capacity = determine_capacity_for_growth( + capacity, + size + 1 + iter.size_hint().0, + core::mem::size_of::(), + ); + unsafe { + result + .inner + .as_ref() + .header + .refcount + .store(0, atomic::Ordering::Relaxed) + }; + let mut iter = IntoIter(IntoIterInner::UnShared(result.inner, 0)); + result.inner = alloc_with_capacity::(capacity); + match &mut iter.0 { + IntoIterInner::UnShared(old_inner, begin) => { + while *begin < size { + unsafe { + core::ptr::write( + result.inner.as_mut().data.as_mut_ptr().add(*begin), + core::ptr::read(old_inner.as_ref().data.as_ptr().add(*begin)), + ); + *begin += 1; + result.inner.as_mut().header.size = *begin; + } + } + } + _ => unreachable!(), + } + } + debug_assert_eq!(result.len(), size); + debug_assert!(result.capacity() > size); + unsafe { + core::ptr::write(result.inner.as_mut().data.as_mut_ptr().add(size), x); + size += 1; + result.inner.as_mut().header.size = size; + } + } + result + } +} + +static SHARED_EMPTY_VEC: VectorHeader = VectorHeader { + refcount: atomic::AtomicIsize::new(-1), + size: 0, + capacity: 0, +}; + +impl Default for Vector { + fn default() -> Self { + Vector { + inner: NonNull::from(&SHARED_EMPTY_VEC).cast(), + } + } +} + +impl Debug for Vector { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + self.as_slice().fmt(f) + } +} + +impl AsRef<[T]> for Vector { + #[inline] + fn as_ref(&self) -> &[T] { + self.as_slice() + } +} + +/// Drops the inner vector and deallocates the memory. This is only really a +/// valid operation if the reference count is 0, otherwise there might be other +/// users. +unsafe fn drop_inner(mut inner: NonNull>) { + debug_assert_eq!( + inner + .as_ref() + .header + .refcount + .load(atomic::Ordering::Relaxed), + 0 + ); + let data_ptr = inner.as_mut().data.as_mut_ptr(); + for x in 0..inner.as_ref().header.size { + core::ptr::drop_in_place(data_ptr.add(x)); + } + std::alloc::dealloc( + inner.as_ptr() as *mut u8, + compute_inner_layout::(inner.as_ref().header.capacity), + ) +} + +impl IntoIterator for Vector { + type Item = T; + type IntoIter = IntoIter; + fn into_iter(self) -> Self::IntoIter { + IntoIter(unsafe { + if self + .inner + .as_ref() + .header + .refcount + .load(atomic::Ordering::Relaxed) + == 1 + { + let inner = self.inner; + core::mem::forget(self); + inner + .as_ref() + .header + .refcount + .store(0, atomic::Ordering::Relaxed); + IntoIterInner::UnShared(inner, 0) + } else { + IntoIterInner::Shared(self, 0) + } + }) + } +} + +enum IntoIterInner { + Shared(Vector, usize), + // Elements up to the usize member are already moved out + UnShared(NonNull>, usize), +} + +impl Drop for IntoIterInner { + fn drop(&mut self) { + match self { + IntoIterInner::Shared(..) => { /* drop of Vector takes care of it */ } + IntoIterInner::UnShared(mut inner, begin) => unsafe { + debug_assert_eq!( + inner + .as_ref() + .header + .refcount + .load(atomic::Ordering::Relaxed), + 0 + ); + let data_ptr = inner.as_mut().data.as_mut_ptr(); + for x in (*begin)..inner.as_ref().header.size { + core::ptr::drop_in_place(data_ptr.add(x)); + } + std::alloc::dealloc( + inner.as_ptr() as *mut u8, + compute_inner_layout::(inner.as_ref().header.capacity), + ) + }, + } + } +} + +/// An iterator that moves out of a Vector. +/// +/// This `struct` is created by the `into_iter` method on [`Vector`] +/// (provided by the [`IntoIterator`] trait). +pub struct IntoIter(IntoIterInner); + +impl Iterator for IntoIter { + type Item = T; + + fn next(&mut self) -> Option { + match &mut self.0 { + IntoIterInner::Shared(array, moved) => { + let result = array.as_slice().get(*moved).cloned(); + *moved += 1; + result + } + IntoIterInner::UnShared(inner, begin) => unsafe { + if *begin < inner.as_ref().header.size { + let r = core::ptr::read(inner.as_ref().data.as_ptr().add(*begin)); + *begin += 1; + Some(r) + } else { + None + } + }, + } + } +} + +/// Determine the memory layout to allocate when a specific capacity of T is +/// requested. +fn compute_inner_layout(capacity: usize) -> core::alloc::Layout { + core::alloc::Layout::new::() + .extend(core::alloc::Layout::array::(capacity).unwrap()) + .unwrap() + .0 +} + +/// Allocate the memory for a Vector with the given capacity. Returns an +/// `inner` with size and refcount set to 1 +fn alloc_with_capacity(capacity: usize) -> NonNull> { + let ptr = unsafe { std::alloc::alloc(compute_inner_layout::(capacity)) }; + assert!(!ptr.is_null(), "allocation of {:?} bytes failed", capacity); + unsafe { + core::ptr::write( + ptr as *mut VectorHeader, + VectorHeader { + refcount: 1.into(), + size: 0, + capacity, + }, + ); + } + NonNull::new(ptr).unwrap().cast() +} + +/// Returns a new capacity suitable to store `required_cap` elements. +/// Loosely based on alloc::raw_vec::RawVec::grow_amortized. +fn determine_capacity_for_growth( + current_cap: usize, + required_cap: usize, + elem_size: usize, +) -> usize { + if current_cap >= required_cap { + return current_cap; + } + let cap = core::cmp::max(current_cap * 2, required_cap); + let min_non_zero_cap = if elem_size == 1 { + 8 + } else if elem_size <= 1024 { + 4 + } else { + 1 + }; + core::cmp::max(min_non_zero_cap, cap) +} + +pub(crate) mod ffi { + use super::*; + + #[no_mangle] + /// This function is used for the low-level C++ interface to allocate the + /// backing vector of a Vector. + pub unsafe extern "C" fn resolvo_vector_allocate(size: usize, align: usize) -> *mut u8 { + std::alloc::alloc(std::alloc::Layout::from_size_align(size, align).unwrap()) + } + + #[no_mangle] + /// This function is used for the low-level C++ interface to deallocate the + /// backing vector of a Vector + pub unsafe extern "C" fn resolvo_vector_free(ptr: *mut u8, size: usize, align: usize) { + std::alloc::dealloc( + ptr, + std::alloc::Layout::from_size_align(size, align).unwrap(), + ) + } + + #[no_mangle] + /// This function is used for the low-level C++ interface to initialize the + /// empty Vector. + pub unsafe extern "C" fn resolvo_vector_empty() -> *const u8 { + &SHARED_EMPTY_VEC as *const _ as *const u8 + } +} diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt new file mode 100644 index 0000000..38ed43f --- /dev/null +++ b/cpp/tests/CMakeLists.txt @@ -0,0 +1,36 @@ +FetchContent_Declare( + Catch2 + GIT_REPOSITORY https://github.com/catchorg/Catch2.git + GIT_TAG v2.13.8 +) + +FetchContent_MakeAvailable(Catch2) + +include(CTest) + +macro(resolvo_test NAME) + add_executable(test_${NAME} ${NAME}.cpp) + target_link_libraries(test_${NAME} PRIVATE Resolvo Catch2::Catch2) + target_compile_definitions(test_${NAME} PRIVATE + SOURCE_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/\" + ) + # Use debug version of run-time library to enable MSVC iterator debugging + set_property(TARGET test_${NAME} PROPERTY MSVC_RUNTIME_LIBRARY MultiThreadedDebugDLL) + add_test(NAME test_${NAME} COMMAND test_${NAME}) + + if(MSVC) + target_compile_options(test_${NAME} PRIVATE /W3) + else() + target_compile_options(test_${NAME} PRIVATE -Wall -Wextra -Werror) + endif() + + if(CMAKE_CXX_COMPILER_ID STREQUAL GNU) + # that warning has false positives + target_compile_options(test_${NAME} PRIVATE -Wno-maybe-uninitialized) + endif() +endmacro(resolvo_test) + +resolvo_test(vector) +resolvo_test(string) +resolvo_test(solve) + diff --git a/cpp/tests/solve.cpp b/cpp/tests/solve.cpp new file mode 100644 index 0000000..4a40d46 --- /dev/null +++ b/cpp/tests/solve.cpp @@ -0,0 +1,192 @@ +#define CATCH_CONFIG_MAIN +#include +#include + +#include + +#include "catch2/catch.hpp" + +/** + * A single candidate for a package. + */ +struct Candidate { + resolvo::NameId name; + uint32_t version; + resolvo::Dependencies dependencies; +}; + +/** + * A requirement for a package. + */ +struct Requirement { + resolvo::NameId name; + uint32_t version_start; + uint32_t version_end; +}; + +/** + * A simple database of packages that also implements resolvos DependencyProvider interface. + */ +struct PackageDatabase : public resolvo::DependencyProvider { + resolvo::Pool names; + resolvo::Pool strings; + std::vector candidates; + std::vector requirements; + + /** + * Allocates a new requirement and return the id of the requirement. + */ + resolvo::VersionSetId alloc_requirement(std::string_view package, uint32_t version_start, + uint32_t version_end) { + auto name_id = names.alloc(std::move(package)); + auto id = resolvo::VersionSetId{static_cast(requirements.size())}; + requirements.push_back(Requirement{name_id, version_start, version_end}); + return id; + } + + /** + * Allocates a new candidate and return the id of the candidate. + */ + resolvo::SolvableId alloc_candidate(std::string_view name, uint32_t version, + resolvo::Dependencies dependencies) { + auto name_id = names.alloc(std::move(name)); + auto id = resolvo::SolvableId{static_cast(candidates.size())}; + candidates.push_back(Candidate{name_id, version, dependencies}); + return id; + } + + resolvo::String display_name(resolvo::NameId name) override { + return resolvo::String(names[name]); + } + + resolvo::String display_solvable(resolvo::SolvableId solvable) override { + const auto& candidate = candidates[solvable.id]; + std::stringstream ss; + ss << names[candidate.name] << "=" << candidate.version; + return resolvo::String(ss.str()); + } + + resolvo::String display_merged_solvables( + resolvo::Slice solvables) override { + if (solvables.empty()) { + return resolvo::String(); + } + + std::stringstream ss; + ss << names[candidates[solvables[0].id].name]; + + bool first = true; + for (const auto& solvable : solvables) { + if (!first) { + ss << " | "; + first = false; + } + + ss << candidates[solvable.id].version; + } + + return resolvo::String(ss.str()); + } + + resolvo::String display_version_set(resolvo::VersionSetId version_set) override { + const auto& req = requirements[version_set.id]; + std::stringstream ss; + ss << req.version_start << ".." << req.version_end; + return resolvo::String(ss.str()); + } + + resolvo::String display_string(resolvo::StringId string_id) override { + return strings[string_id]; + } + + resolvo::NameId version_set_name(resolvo::VersionSetId version_set_id) override { + return requirements[version_set_id.id].name; + } + + resolvo::NameId solvable_name(resolvo::SolvableId solvable_id) override { + return candidates[solvable_id.id].name; + } + + resolvo::Candidates get_candidates(resolvo::NameId package) override { + resolvo::Candidates result; + + for (uint32_t i = 0; i < static_cast(candidates.size()); ++i) { + const auto& candidate = candidates[i]; + if (candidate.name != package) { + continue; + } + result.candidates.push_back(resolvo::SolvableId{i}); + result.hint_dependencies_available.push_back(resolvo::SolvableId{i}); + } + + result.favored = nullptr; + result.locked = nullptr; + + return result; + } + + void sort_candidates(resolvo::Slice solvables) override { + std::sort(solvables.begin(), solvables.end(), + [&](resolvo::SolvableId a, resolvo::SolvableId b) { + return candidates[a.id].version > candidates[b.id].version; + }); + } + + resolvo::Vector filter_candidates( + resolvo::Slice solvables, resolvo::VersionSetId version_set_id, + bool inverse) override { + resolvo::Vector result; + const auto& requirement = requirements[version_set_id.id]; + for (auto solvable : solvables) { + const auto& candidate = candidates[solvable.id]; + bool matches = candidate.version >= requirement.version_start && + candidate.version < requirement.version_end; + if (matches != inverse) { + result.push_back(solvable); + } + } + return result; + } + + resolvo::Dependencies get_dependencies(resolvo::SolvableId solvable) override { + const auto& candidate = candidates[solvable.id]; + return candidate.dependencies; + } +}; + +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#elif defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunused-variable" +#endif + +SCENARIO("Solve") { + /// Construct a database with packages a, b, and c. + PackageDatabase db; + + auto a_1 = db.alloc_candidate("a", 1, {{db.alloc_requirement("b", 1, 4)}, {}}); + auto a_2 = db.alloc_candidate("a", 2, {{db.alloc_requirement("b", 1, 4)}, {}}); + auto a_3 = db.alloc_candidate("a", 3, {{db.alloc_requirement("b", 4, 7)}, {}}); + + auto b_1 = db.alloc_candidate("b", 1, {}); + auto b_2 = db.alloc_candidate("b", 2, {}); + auto b_3 = db.alloc_candidate("b", 3, {}); + + auto c_1 = db.alloc_candidate("c", 1, {}); + + // Construct a problem to be solved by the solver + resolvo::Vector requirements = {db.alloc_requirement("a", 1, 3)}; + resolvo::Vector constraints = {db.alloc_requirement("b", 1, 3), + db.alloc_requirement("c", 1, 3)}; + + // Solve the problem + resolvo::Vector result; + resolvo::solve(db, requirements, constraints, result); + + // Check the result + REQUIRE(result.size() == 2); + REQUIRE(result[0] == a_2); + REQUIRE(result[1] == b_2); +} diff --git a/cpp/tests/string.cpp b/cpp/tests/string.cpp new file mode 100644 index 0000000..d1a95d7 --- /dev/null +++ b/cpp/tests/string.cpp @@ -0,0 +1,6 @@ +#define CATCH_CONFIG_MAIN +#include + +#include "catch2/catch.hpp" + +SCENARIO("String") { resolvo::String a("Hello, world!"); } diff --git a/cpp/tests/vector.cpp b/cpp/tests/vector.cpp new file mode 100644 index 0000000..91092f6 --- /dev/null +++ b/cpp/tests/vector.cpp @@ -0,0 +1,20 @@ +#define CATCH_CONFIG_MAIN +#include + +#include "catch2/catch.hpp" + +SCENARIO("Vector") { + resolvo::Vector a{1, 2, 3, 4}; + REQUIRE(a.capacity() >= 4); + REQUIRE(a.size() == 4); + + resolvo::Vector b = a; + REQUIRE(b.capacity() >= 4); + REQUIRE(b.size() == 4); + + REQUIRE(a == b); + + b.push_back(4); + REQUIRE(b.size() == 5); + REQUIRE(a.size() == 4); +} diff --git a/pixi.lock b/pixi.lock new file mode 100644 index 0000000..763bbf4 --- /dev/null +++ b/pixi.lock @@ -0,0 +1,3074 @@ +version: 5 +environments: + default: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: {} + format-cpp: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-18-18.1.6-default_h127d8a8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-18.1.6-default_h127d8a8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-73.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp18.1-18.1.6-default_h127d8a8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.17-hd590300_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm18-18.1.6-hb77312f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.12.7-hc051c1a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda + osx-64: + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-format-18-18.1.6-default_ha3b9224_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-format-18.1.6-default_ha3b9224_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-73.2-hf5e326d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.6-default_ha3b9224_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.17-hd75f5a5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.6-hd5e122f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.12.7-h3e169fe_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.6-h915ae27_0.conda + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-18-18.1.6-default_h7c89ad4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-18.1.6-default_h7c89ad4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-73.2-hc8870d7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.6-default_h7c89ad4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.17-h0d3ecfb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.6-hdac5640_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.12.7-ha661575_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.6-hb46c0d2_0.conda + win-64: + - conda: https://conda.anaconda.org/conda-forge/win-64/clang-format-18.1.6-default_h3a3e6c3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-ha32ba9b_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.38.33135-h835141b_20.conda + test-cpp: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.40-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.40-ha1999f0_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.40-hdade7a5_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.28.1-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.7.0-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-3.29.4-h91dbaaa_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.7.0-h00ab1b0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-12.3.0-h915e2ae_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-12.3.0-h58ffeeb_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-12.3.0-h6477408_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-12.3.0-h915e2ae_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-12.3.0-h2a574ab_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-12.3.0-h4a1b8e8_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-2.6.32-he073ed8_17.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.2-h659d440_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.8.0-hca28451_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.2-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-12.3.0-h0223996_107.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.58.0-h47da74e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-12.3.0-hb8811af_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.0-h0841786_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-12.3.0-h0223996_107.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.48.0-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.12.1-h297d8ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.4-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rust-1.75.0-h70c747d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-unknown-linux-gnu-1.75.0-h2c6d0dc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.12-he073ed8_17.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda + osx-64: + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.28.1-h10d778d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.7.0-h282daa2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-986-h40f6528_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-986-ha1c5b94_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-16-16.0.6-default_h4c8afb6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-16.0.6-hd4457cd_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-16.0.6-h8787910_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-16.0.6-hb91bd55_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-16.0.6-default_ha3b9224_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-16.0.6-h6d92fbe_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-16.0.6-hb91bd55_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-3.29.4-h1304840_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-16.0.6-ha38d28d_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-16.0.6-ha38d28d_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.7.0-h7728843_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-73.2-hf5e326d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.2-hb884880_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-711-ha02d983_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-711-ha20a434_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp16-16.0.6-default_h4c8afb6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.8.0-hf9fcc65_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20191231-h0678c8f_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.2-h73e2aa4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.17-hd75f5a5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm16-16.0.6-hbedff68_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.58.0-h64cf6d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.0-hd019ec5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.48.0-h67532ce_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.12.7-h3e169fe_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.6-h15ab845_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-16.0.6-hbedff68_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.12.1-h3c5361c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.4-h0dc2134_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/rust-1.75.0-h7e1429e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-apple-darwin-1.75.0-h38e4360_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/sigtool-0.1.3-h88f4db0_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/tapi-1100.0.11-h9ce4665_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.6-h915ae27_0.conda + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.28.1-h93a5062_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.7.0-h6aa9301_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-986-h4faf515_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-986-h62378fb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-16-16.0.6-default_hb63da90_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-16.0.6-h7bc9447_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-16.0.6-hc421ffc_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-16.0.6-h54d7cd3_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-16.0.6-default_h095aff0_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-16.0.6-hcd7bac0_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-16.0.6-h54d7cd3_15.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-3.29.4-h2cf84f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-16.0.6-h3808999_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-16.0.6-h3808999_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.7.0-h2ffa867_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-73.2-hc8870d7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.2-h92f50d5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-711-h634c8be_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-711-ha4bd21c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp16-16.0.6-default_hb63da90_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.8.0-h7b6f9a7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.2-hebf3989_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.17-h0d3ecfb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm16-16.0.6-haab561b_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.58.0-ha4dd798_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.0-h7a5bd25_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.48.0-h93a5062_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.12.7-ha661575_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.6-hde57baf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-16.0.6-haab561b_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.12.1-h420ef59_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.4-hb547adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rust-1.75.0-h4ff7c5d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rust-std-aarch64-apple-darwin-1.75.0-hf6ec828_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-0.1.3-h44b9a77_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1100.0.11-he4954df_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.6-hb46c0d2_0.conda + win-64: + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-3.29.4-h75d51d9_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.7.0-h91493d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.2-heb0366b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.8.0-hd5e4a3a_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.6.2-h63175ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.0-h7dfc565_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.48.0-hcfcfb64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.12.1-hc790b64_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/rust-1.75.0-hf8d6059_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-pc-windows-msvc-1.75.0-h17fc481_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-ha32ba9b_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.38.33135-h835141b_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.38.33135-h22015db_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2019_win-64-19.29.30139-he1865b1_20.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vswhere-3.1.4-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.6-h0ea2cb4_0.conda + test-rust: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.40-ha1999f0_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-12.3.0-h58ffeeb_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-2.6.32-he073ed8_17.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-12.3.0-h0223996_107.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-12.3.0-hb8811af_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rust-1.75.0-h70c747d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-unknown-linux-gnu-1.75.0-h2c6d0dc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.12-he073ed8_17.conda + osx-64: + - conda: https://conda.anaconda.org/conda-forge/osx-64/rust-1.75.0-h7e1429e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-apple-darwin-1.75.0-h38e4360_0.conda + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rust-1.75.0-h4ff7c5d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rust-std-aarch64-apple-darwin-1.75.0-hf6ec828_0.conda + win-64: + - conda: https://conda.anaconda.org/conda-forge/win-64/rust-1.75.0-hf8d6059_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-pc-windows-msvc-1.75.0-h17fc481_0.conda +packages: +- kind: conda + name: _libgcc_mutex + version: '0.1' + build: conda_forge + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + sha256: fe51de6107f9edc7aa4f786a70f4a883943bc9d39b3bb7307c04c41410990726 + md5: d7c89558ba9fa0495403155b64376d81 + license: None + size: 2562 + timestamp: 1578324546067 +- kind: conda + name: _openmp_mutex + version: '4.5' + build: 2_gnu + build_number: 16 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + sha256: fbe2c5e56a653bebb982eda4876a9178aedfc2b545f25d0ce9c4c0b508253d22 + md5: 73aaf86a425cc6e73fcf236a5a46396d + depends: + - _libgcc_mutex 0.1 conda_forge + - libgomp >=7.5.0 + constrains: + - openmp_impl 9999 + license: BSD-3-Clause + license_family: BSD + size: 23621 + timestamp: 1650670423406 +- kind: conda + name: binutils + version: '2.40' + build: h4852527_2 + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.40-h4852527_2.conda + sha256: 89f06321896092d2d931fc40cd6753f11dfe90ebb9d180c9512b614a7b623423 + md5: 0ea11d9433ec00000e96e82d6381671d + depends: + - binutils_impl_linux-64 >=2.40,<2.41.0a0 + license: GPL-3.0-only + license_family: GPL + size: 31105 + timestamp: 1717523048004 +- kind: conda + name: binutils_impl_linux-64 + version: '2.40' + build: ha1999f0_2 + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.40-ha1999f0_2.conda + sha256: 93965e6d95da53fa2ead26298eeb8ab53b8e9da0732c4baee2f4ce7d9c16aec1 + md5: 861a9d0b9ad43dcebe5a76f38a7d2527 + depends: + - ld_impl_linux-64 2.40 hf3520f5_2 + - sysroot_linux-64 + license: GPL-3.0-only + license_family: GPL + size: 5584502 + timestamp: 1717523025003 +- kind: conda + name: binutils_linux-64 + version: '2.40' + build: hdade7a5_3 + build_number: 3 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.40-hdade7a5_3.conda + sha256: d114b825acef51c1d065ca0a17f97e0e856c48765aecf2f8f164935635013dd2 + md5: 2d9a60578bc28469d9aeef9aea5520c3 + depends: + - binutils_impl_linux-64 2.40.* + - sysroot_linux-64 + license: BSD-3-Clause + license_family: BSD + size: 28868 + timestamp: 1710259805994 +- kind: conda + name: bzip2 + version: 1.0.8 + build: h10d778d_5 + build_number: 5 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h10d778d_5.conda + sha256: 61fb2b488928a54d9472113e1280b468a309561caa54f33825a3593da390b242 + md5: 6097a6ca9ada32699b5fc4312dd6ef18 + license: bzip2-1.0.6 + license_family: BSD + size: 127885 + timestamp: 1699280178474 +- kind: conda + name: bzip2 + version: 1.0.8 + build: h93a5062_5 + build_number: 5 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h93a5062_5.conda + sha256: bfa84296a638bea78a8bb29abc493ee95f2a0218775642474a840411b950fe5f + md5: 1bbc659ca658bfd49a481b5ef7a0f40f + license: bzip2-1.0.6 + license_family: BSD + size: 122325 + timestamp: 1699280294368 +- kind: conda + name: bzip2 + version: 1.0.8 + build: hcfcfb64_5 + build_number: 5 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-hcfcfb64_5.conda + sha256: ae5f47a5c86fd6db822931255dcf017eb12f60c77f07dc782ccb477f7808aab2 + md5: 26eb8ca6ea332b675e11704cce84a3be + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: bzip2-1.0.6 + license_family: BSD + size: 124580 + timestamp: 1699280668742 +- kind: conda + name: bzip2 + version: 1.0.8 + build: hd590300_5 + build_number: 5 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hd590300_5.conda + sha256: 242c0c324507ee172c0e0dd2045814e746bb303d1eb78870d182ceb0abc726a8 + md5: 69b8b6202a07720f448be700e300ccf4 + depends: + - libgcc-ng >=12 + license: bzip2-1.0.6 + license_family: BSD + size: 254228 + timestamp: 1699279927352 +- kind: conda + name: c-ares + version: 1.28.1 + build: h10d778d_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.28.1-h10d778d_0.conda + sha256: fccd7ad7e3dfa6b19352705b33eb738c4c55f79f398e106e6cf03bab9415595a + md5: d5eb7992227254c0e9a0ce71151f0079 + license: MIT + license_family: MIT + size: 152607 + timestamp: 1711819681694 +- kind: conda + name: c-ares + version: 1.28.1 + build: h93a5062_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.28.1-h93a5062_0.conda + sha256: 2fc553d7a75e912efbdd6b82cd7916cc9cb2773e6cd873b77e02d631dd7be698 + md5: 04f776a6139f7eafc2f38668570eb7db + license: MIT + license_family: MIT + size: 150488 + timestamp: 1711819630164 +- kind: conda + name: c-ares + version: 1.28.1 + build: hd590300_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.28.1-hd590300_0.conda + sha256: cb25063f3342149c7924b21544109696197a9d774f1407567477d4f3026bf38a + md5: dcde58ff9a1f30b0037a2315d1846d1f + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 168875 + timestamp: 1711819445938 +- kind: conda + name: c-compiler + version: 1.7.0 + build: h282daa2_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.7.0-h282daa2_1.conda + sha256: a8e2e2b121e61e3d6a67aa618602815211573e96477ab048176a831ae622bfaf + md5: d27411cb82bc1b76b9f487da6ae97f1d + depends: + - cctools >=949.0.1 + - clang_osx-64 16.* + - ld64 >=530 + - llvm-openmp + license: BSD-3-Clause + license_family: BSD + size: 6396 + timestamp: 1714575615177 +- kind: conda + name: c-compiler + version: 1.7.0 + build: h6aa9301_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.7.0-h6aa9301_1.conda + sha256: dcff26a7e70681945955b6267306e6436b77bf83b34fa0fc81e3c96960c7a1db + md5: c12b8656251acd221948e4970e8539d1 + depends: + - cctools >=949.0.1 + - clang_osx-arm64 16.* + - ld64 >=530 + - llvm-openmp + license: BSD-3-Clause + license_family: BSD + size: 6411 + timestamp: 1714575604618 +- kind: conda + name: c-compiler + version: 1.7.0 + build: hd590300_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.7.0-hd590300_1.conda + sha256: 4213b6cbaed673c07f8b79c089f3487afdd56de944f21c4861ead862b7657eb4 + md5: e9dffe1056994133616378309f932d77 + depends: + - binutils + - gcc + - gcc_linux-64 12.* + license: BSD-3-Clause + license_family: BSD + size: 6324 + timestamp: 1714575511013 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: h56e8100_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ca-certificates-2024.6.2-h56e8100_0.conda + sha256: d872d11558ebeaeb87bcf9086e97c075a1a2dfffed2d0e97570cf197ab29e3d8 + md5: 12a3a2b3a00a21bbb390d4de5ad8dd0f + license: ISC + size: 156530 + timestamp: 1717311907623 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: h8857fd0_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.6.2-h8857fd0_0.conda + sha256: ba0614477229fcb0f0666356f2c4686caa66f0ed1446e7c9666ce234abe2bacf + md5: 3c23a8cab15ae51ebc9efdc229fccecf + license: ISC + size: 156145 + timestamp: 1717311781754 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: hbcca054_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.6.2-hbcca054_0.conda + sha256: 979af0932b2a5a26112044891a2d79e402e5ae8166f50fa48b8ebae47c0a2d65 + md5: 847c3c2905cc467cea52c24f9cfa8080 + license: ISC + size: 156035 + timestamp: 1717311767102 +- kind: conda + name: ca-certificates + version: 2024.6.2 + build: hf0a4a13_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ca-certificates-2024.6.2-hf0a4a13_0.conda + sha256: f5fd189d48965df396d060eb48628cbd9f083f1a1ea79c5236f60d655c7b9633 + md5: b534f104f102479402f88f73adf750f5 + license: ISC + size: 156299 + timestamp: 1717311742040 +- kind: conda + name: cctools + version: '986' + build: h40f6528_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/cctools-986-h40f6528_0.conda + sha256: 4eac1d10ddafb1dc277ddff304a7d314607c7dc99d7a77d69ed75f8fcbdf93d4 + md5: b7a2ca0062a6ee8bc4e83ec887bef942 + depends: + - cctools_osx-64 986 ha1c5b94_0 + - ld64 711 ha02d983_0 + - libllvm16 >=16.0.6,<16.1.0a0 + license: APSL-2.0 + license_family: Other + size: 21663 + timestamp: 1710466476542 +- kind: conda + name: cctools + version: '986' + build: h4faf515_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-986-h4faf515_0.conda + sha256: 505471dfa37dc42ba1a2c4cf65d4c4abe4c36164c8fcb0a375e3c4f3550ab3ee + md5: d81c4480e8445b13129024191231e6c5 + depends: + - cctools_osx-arm64 986 h62378fb_0 + - ld64 711 h634c8be_0 + - libllvm16 >=16.0.6,<16.1.0a0 + license: APSL-2.0 + license_family: Other + size: 21683 + timestamp: 1710466813384 +- kind: conda + name: cctools_osx-64 + version: '986' + build: ha1c5b94_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-986-ha1c5b94_0.conda + sha256: 16ef6a8dd367d7d4d7b3446f73ed95b07603d6b5b3256c3acab9b3a9006ef7eb + md5: a8951de2506df5649f5a3295fdfd9f2c + depends: + - ld64_osx-64 >=711,<712.0a0 + - libcxx + - libllvm16 >=16.0.6,<16.1.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - sigtool + constrains: + - ld64 711.* + - cctools 986.* + - clang 16.0.* + license: APSL-2.0 + license_family: Other + size: 1118961 + timestamp: 1710466421642 +- kind: conda + name: cctools_osx-arm64 + version: '986' + build: h62378fb_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-986-h62378fb_0.conda + sha256: 35907653456fdd854b426060980025689670784c677e2bbecd2fcaf983cfa37c + md5: cb85035a5eceb3a0d3becc1026dbb31d + depends: + - ld64_osx-arm64 >=711,<712.0a0 + - libcxx + - libllvm16 >=16.0.6,<16.1.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - sigtool + constrains: + - clang 16.0.* + - ld64 711.* + - cctools 986.* + license: APSL-2.0 + license_family: Other + size: 1127544 + timestamp: 1710466751857 +- kind: conda + name: clang + version: 16.0.6 + build: h7bc9447_7 + build_number: 7 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clang-16.0.6-h7bc9447_7.conda + sha256: 5f04b3a7e576861db61a04aa4824b8196e4cafe92c79a9290fc5eafd4531f010 + md5: 172328871c92aea74ff3b71064f66cb7 + depends: + - clang-16 16.0.6 default_hb63da90_7 + constrains: + - clang-tools 16.0.6.* + - llvm 16.0.6.* + - llvm-tools 16.0.6.* + - llvmdev 16.0.6.* + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 81852 + timestamp: 1716981232520 +- kind: conda + name: clang + version: 16.0.6 + build: hd4457cd_7 + build_number: 7 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clang-16.0.6-hd4457cd_7.conda + sha256: 2efeb86a87ded2ae4021fb968a15d403619df2ce571713d7e281268208f72fd7 + md5: 0f91e4c1d9d85887db66ddbc185d65d4 + depends: + - clang-16 16.0.6 default_h4c8afb6_7 + constrains: + - clang-tools 16.0.6.* + - llvm 16.0.6.* + - llvm-tools 16.0.6.* + - llvmdev 16.0.6.* + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 81750 + timestamp: 1716980780083 +- kind: conda + name: clang-16 + version: 16.0.6 + build: default_h4c8afb6_7 + build_number: 7 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clang-16-16.0.6-default_h4c8afb6_7.conda + sha256: 3bf8f0f55fb5eaed9e7f9b647ececb941a1342d14f20d7772fd4328d58912e4f + md5: c9da6a62b571cac3707db69610ed7bd3 + depends: + - __osx >=10.13 + - libclang-cpp16 16.0.6 default_h4c8afb6_7 + - libcxx >=16.0.6 + - libllvm16 >=16.0.6,<16.1.0a0 + constrains: + - clangxx 16.0.6 + - clangdev 16.0.6 + - clang-tools 16.0.6 + - llvm-tools 16.0.6 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 758914 + timestamp: 1716980696120 +- kind: conda + name: clang-16 + version: 16.0.6 + build: default_hb63da90_7 + build_number: 7 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clang-16-16.0.6-default_hb63da90_7.conda + sha256: 51358152f76a4d363459f68fa6cd8f5c88edf6bd09ec8de10970754fb1dc9c91 + md5: 73fa4ed0b361a6882bc3893f16ce0f07 + depends: + - __osx >=11.0 + - libclang-cpp16 16.0.6 default_hb63da90_7 + - libcxx >=16.0.6 + - libllvm16 >=16.0.6,<16.1.0a0 + constrains: + - clangxx 16.0.6 + - clang-tools 16.0.6 + - clangdev 16.0.6 + - llvm-tools 16.0.6 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 751242 + timestamp: 1716981084563 +- kind: conda + name: clang-format + version: 18.1.6 + build: default_h127d8a8_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/clang-format-18.1.6-default_h127d8a8_0.conda + sha256: 7d111926d120b755b186ae204e5601be7bd8d535a65c20e20ec77c59b4ec8210 + md5: 5793db63d12fb3861fbc0757dfa72ba6 + depends: + - clang-format-18 18.1.6 default_h127d8a8_0 + - libclang-cpp18.1 >=18.1.6,<18.2.0a0 + - libgcc-ng >=12 + - libllvm18 >=18.1.6,<18.2.0a0 + - libstdcxx-ng >=12 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 22619 + timestamp: 1716714975627 +- kind: conda + name: clang-format + version: 18.1.6 + build: default_h3a3e6c3_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/clang-format-18.1.6-default_h3a3e6c3_0.conda + sha256: fe1f3b18dd52b929db7a407c5725af2330365f4fabbbf8445fd5c765e4a822b0 + md5: 5f500e8080af1e06be3290e1fb5e209a + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 1182092 + timestamp: 1716718626420 +- kind: conda + name: clang-format + version: 18.1.6 + build: default_h7c89ad4_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-18.1.6-default_h7c89ad4_0.conda + sha256: 020ed5064bd855cff660721523983117eb90140d456121fda8e92b623cfaccb1 + md5: de593d77089cc395d7f1c7d62cb57d0c + depends: + - clang-format-18 18.1.6 default_h7c89ad4_0 + - libclang-cpp18.1 >=18.1.6,<18.2.0a0 + - libcxx >=16.0.6 + - libllvm18 >=18.1.6,<18.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 22938 + timestamp: 1716713640664 +- kind: conda + name: clang-format + version: 18.1.6 + build: default_ha3b9224_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clang-format-18.1.6-default_ha3b9224_0.conda + sha256: a0c828ade3b1fa54fb0eaff9a17a77ec65ac61ab50bf5c4bc9313daa8ff1d463 + md5: d4c49cec403dd710e67dbf5fd1072f86 + depends: + - clang-format-18 18.1.6 default_ha3b9224_0 + - libclang-cpp18.1 >=18.1.6,<18.2.0a0 + - libcxx >=16.0.6 + - libllvm18 >=18.1.6,<18.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 22775 + timestamp: 1716713290315 +- kind: conda + name: clang-format-18 + version: 18.1.6 + build: default_h127d8a8_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/clang-format-18-18.1.6-default_h127d8a8_0.conda + sha256: b4732ca96df23fd07f0a8dad0a46ec5a6d9e5f3e28e1a63c10e592ee6e518cc4 + md5: d8a9e4d1ae88258ef17e06200953807c + depends: + - libclang-cpp18.1 >=18.1.6,<18.2.0a0 + - libgcc-ng >=12 + - libllvm18 >=18.1.6,<18.2.0a0 + - libstdcxx-ng >=12 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 65852 + timestamp: 1716714930189 +- kind: conda + name: clang-format-18 + version: 18.1.6 + build: default_h7c89ad4_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-18-18.1.6-default_h7c89ad4_0.conda + sha256: 30f4793b436d71a89a429b6973414a9974944192adfe2c21c5ebd7845d53fded + md5: 71014e29c45321f3c4bdf013db236177 + depends: + - libclang-cpp18.1 >=18.1.6,<18.2.0a0 + - libcxx >=16.0.6 + - libllvm18 >=18.1.6,<18.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 60494 + timestamp: 1716713570984 +- kind: conda + name: clang-format-18 + version: 18.1.6 + build: default_ha3b9224_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clang-format-18-18.1.6-default_ha3b9224_0.conda + sha256: 49bb8ed6fe218e96eed4d5ae045a77aa6cb3e73e4cffa020c93602b0463220c6 + md5: 2938075fa3c2f96d07036e0bbce69153 + depends: + - libclang-cpp18.1 >=18.1.6,<18.2.0a0 + - libcxx >=16.0.6 + - libllvm18 >=18.1.6,<18.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 62081 + timestamp: 1716713224334 +- kind: conda + name: clang_impl_osx-64 + version: 16.0.6 + build: h8787910_15 + build_number: 15 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-16.0.6-h8787910_15.conda + sha256: 2bf8acbe3590ffc25398b4c9dac85d5937b39f2ea51c8347a02836848783e260 + md5: 4604a48f32935cd5d6e6a48e818b7eb0 + depends: + - cctools_osx-64 + - clang 16.0.6.* + - compiler-rt 16.0.6.* + - ld64_osx-64 + - llvm-tools 16.0.6.* + license: BSD-3-Clause + license_family: BSD + size: 17500 + timestamp: 1716758662891 +- kind: conda + name: clang_impl_osx-arm64 + version: 16.0.6 + build: hc421ffc_15 + build_number: 15 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-16.0.6-hc421ffc_15.conda + sha256: 7a6f213f73bae398a66dcde42375e0b13173ab005b292a9539bf978e4f86d808 + md5: 327e0c0022c1db7c390622c247483652 + depends: + - cctools_osx-arm64 + - clang 16.0.6.* + - compiler-rt 16.0.6.* + - ld64_osx-arm64 + - llvm-tools 16.0.6.* + license: BSD-3-Clause + license_family: BSD + size: 17562 + timestamp: 1716758701036 +- kind: conda + name: clang_osx-64 + version: 16.0.6 + build: hb91bd55_15 + build_number: 15 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-16.0.6-hb91bd55_15.conda + sha256: fa671e245773815a8fd16a1f27f046ea159277ca63343ac438c29ad34dbf2ba8 + md5: dc667dff0fefcb19ab8318e9518011f3 + depends: + - clang_impl_osx-64 16.0.6 h8787910_15 + license: BSD-3-Clause + license_family: BSD + size: 20534 + timestamp: 1716758669450 +- kind: conda + name: clang_osx-arm64 + version: 16.0.6 + build: h54d7cd3_15 + build_number: 15 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-16.0.6-h54d7cd3_15.conda + sha256: d45e3077906bab088b0b9a5ced9bba306189fddb229a975090594ca6bb9b71bf + md5: d9f7d9cd0d0f6650864edbb70da2bac4 + depends: + - clang_impl_osx-arm64 16.0.6 hc421ffc_15 + license: BSD-3-Clause + license_family: BSD + size: 20499 + timestamp: 1716758707804 +- kind: conda + name: clangxx + version: 16.0.6 + build: default_h095aff0_7 + build_number: 7 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-16.0.6-default_h095aff0_7.conda + sha256: 0daea36dfbd5fc8f86ef987b04a684c7eb492fbf2d74c6329e856e029a786dcd + md5: 3605798690eee4fa8f82ac6519caba2a + depends: + - clang 16.0.6 h7bc9447_7 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 82005 + timestamp: 1716981247780 +- kind: conda + name: clangxx + version: 16.0.6 + build: default_ha3b9224_7 + build_number: 7 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clangxx-16.0.6-default_ha3b9224_7.conda + sha256: 9e3492ddc9fe706d88795b70fd662a7703d9157f94d3e5cd062f70f731c691ff + md5: 00c8a212cbbd427dcbcc4231b23ddc5e + depends: + - clang 16.0.6 hd4457cd_7 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 81879 + timestamp: 1716980792681 +- kind: conda + name: clangxx_impl_osx-64 + version: 16.0.6 + build: h6d92fbe_15 + build_number: 15 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-16.0.6-h6d92fbe_15.conda + sha256: e0b9f2436514ac5e79a66dcd4fc3f61ebb79e2f025647c87963c58587340853b + md5: 0e9dfa5ea554d23a3ad1f373470f84a2 + depends: + - clang_osx-64 16.0.6 hb91bd55_15 + - clangxx 16.0.6.* + - libcxx >=16 + - libllvm16 >=16.0.6,<16.1.0a0 + license: BSD-3-Clause + license_family: BSD + size: 17585 + timestamp: 1716758703238 +- kind: conda + name: clangxx_impl_osx-arm64 + version: 16.0.6 + build: hcd7bac0_15 + build_number: 15 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-16.0.6-hcd7bac0_15.conda + sha256: b6734a6857412a4e84e11ccfed6ae69df141d77eaa4400a3fbe1c01863608275 + md5: 6a1fb927362d036f4964ef9ad74e8df0 + depends: + - clang_osx-arm64 16.0.6 h54d7cd3_15 + - clangxx 16.0.6.* + - libcxx >=16 + - libllvm16 >=16.0.6,<16.1.0a0 + license: BSD-3-Clause + license_family: BSD + size: 17661 + timestamp: 1716758733558 +- kind: conda + name: clangxx_osx-64 + version: 16.0.6 + build: hb91bd55_15 + build_number: 15 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-16.0.6-hb91bd55_15.conda + sha256: 1e16d2133f04a5bac0b35809a0fd65db7e6a4634db313591cf31101d7477a904 + md5: 3d3b8b7b99770601759ef8bc23264df2 + depends: + - clang_osx-64 16.0.6 hb91bd55_15 + - clangxx_impl_osx-64 16.0.6 h6d92fbe_15 + license: BSD-3-Clause + license_family: BSD + size: 19275 + timestamp: 1716758709686 +- kind: conda + name: clangxx_osx-arm64 + version: 16.0.6 + build: h54d7cd3_15 + build_number: 15 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-16.0.6-h54d7cd3_15.conda + sha256: 889f26a0db11f5aa142fdd3aff07dc2ecb815d15dd5193d13366aa74c87c5110 + md5: 1a54f30253dbc52aef6b06304982d089 + depends: + - clang_osx-arm64 16.0.6 h54d7cd3_15 + - clangxx_impl_osx-arm64 16.0.6 hcd7bac0_15 + license: BSD-3-Clause + license_family: BSD + size: 19221 + timestamp: 1716758740702 +- kind: conda + name: cmake + version: 3.29.4 + build: h1304840_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/cmake-3.29.4-h1304840_0.conda + sha256: 56b61469b3fb2a3275a5eb599a9caf366fc0ef3e886d8e547e25fbdd1f3b2b1b + md5: 106e091802d2a8fac3b93eb82d35908a + depends: + - __osx >=10.13 + - bzip2 >=1.0.8,<2.0a0 + - libcurl >=8.8.0,<9.0a0 + - libcxx >=16 + - libexpat >=2.6.2,<3.0a0 + - libuv >=1.48.0,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - ncurses >=6.5,<7.0a0 + - rhash >=1.4.4,<2.0a0 + - xz >=5.2.6,<6.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: BSD-3-Clause + license_family: BSD + size: 17387529 + timestamp: 1717458067632 +- kind: conda + name: cmake + version: 3.29.4 + build: h2cf84f3_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-3.29.4-h2cf84f3_0.conda + sha256: 3ac81b2a3ad594ed426e3e8f1951f687defe561c8331de2dfa2602ab525af11a + md5: 1a308493d30d9ebb147e72fbd59c831d + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libcurl >=8.8.0,<9.0a0 + - libcxx >=16 + - libexpat >=2.6.2,<3.0a0 + - libuv >=1.48.0,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - ncurses >=6.5,<7.0a0 + - rhash >=1.4.4,<2.0a0 + - xz >=5.2.6,<6.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: BSD-3-Clause + license_family: BSD + size: 16240005 + timestamp: 1717457707074 +- kind: conda + name: cmake + version: 3.29.4 + build: h75d51d9_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/cmake-3.29.4-h75d51d9_0.conda + sha256: da67ba2cf6d5b87ebdd219ccb0b0a89376b6be26d30abc1e83e473a91d02ea0e + md5: 4a6005b5f6ed640dce98af55cef38e95 + depends: + - bzip2 >=1.0.8,<2.0a0 + - libcurl >=8.8.0,<9.0a0 + - libexpat >=2.6.2,<3.0a0 + - libuv >=1.48.0,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - ucrt >=10.0.20348.0 + - vc14_runtime >=14.29.30139 + - xz >=5.2.6,<6.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: BSD-3-Clause + license_family: BSD + size: 13894184 + timestamp: 1717458034374 +- kind: conda + name: cmake + version: 3.29.4 + build: h91dbaaa_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/cmake-3.29.4-h91dbaaa_0.conda + sha256: 80c39e10ace7733829220bb382acddd42cf0d698dc7541bfaf9c5fb325cab6b0 + md5: d07b4431d37186cf69ef63a2aba6f47a + depends: + - bzip2 >=1.0.8,<2.0a0 + - libcurl >=8.8.0,<9.0a0 + - libexpat >=2.6.2,<3.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libuv >=1.48.0,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - ncurses >=6.5,<7.0a0 + - rhash >=1.4.4,<2.0a0 + - xz >=5.2.6,<6.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: BSD-3-Clause + license_family: BSD + size: 19024763 + timestamp: 1717457328163 +- kind: conda + name: compiler-rt + version: 16.0.6 + build: h3808999_2 + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-16.0.6-h3808999_2.conda + sha256: 67f6883f37ea720f97d016c3384962d86ec8853e5f4b0065aa77e335ca80193e + md5: 517f18b3260bb7a508d1f54a96e6285b + depends: + - clang 16.0.6.* + - clangxx 16.0.6.* + - compiler-rt_osx-arm64 16.0.6.* + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 93724 + timestamp: 1701467327657 +- kind: conda + name: compiler-rt + version: 16.0.6 + build: ha38d28d_2 + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-16.0.6-ha38d28d_2.conda + sha256: de0e2c94d9a04f60ec9aedde863d6c1fad3f261bdb63ec8adc70e2d9ecdb07bb + md5: 3b9e8c5c63b8e86234f499490acd85c2 + depends: + - clang 16.0.6.* + - clangxx 16.0.6.* + - compiler-rt_osx-64 16.0.6.* + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 94198 + timestamp: 1701467261175 +- kind: conda + name: compiler-rt_osx-64 + version: 16.0.6 + build: ha38d28d_2 + build_number: 2 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-16.0.6-ha38d28d_2.conda + sha256: 75270bd8e306967f6e1a8c17d14f2dfe76602a5c162088f3ea98034fe3d71e0c + md5: 7a46507edc35c6c8818db0adaf8d787f + depends: + - clang 16.0.6.* + - clangxx 16.0.6.* + constrains: + - compiler-rt 16.0.6 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 9895261 + timestamp: 1701467223753 +- kind: conda + name: compiler-rt_osx-arm64 + version: 16.0.6 + build: h3808999_2 + build_number: 2 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-16.0.6-h3808999_2.conda + sha256: 61f1a10e6e8ec147f17c5e36cf1c2fe77ac6d1907b05443fa319fd59be20fa33 + md5: 8c7d77d888e1a218cccd9e82b1458ec6 + depends: + - clang 16.0.6.* + - clangxx 16.0.6.* + constrains: + - compiler-rt 16.0.6 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 9829914 + timestamp: 1701467293179 +- kind: conda + name: cxx-compiler + version: 1.7.0 + build: h00ab1b0_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.7.0-h00ab1b0_1.conda + sha256: cf895938292cfd4cfa2a06c6d57aa25c33cc974d4ffe52e704ffb67f5577b93f + md5: 28de2e073db9ca9b72858bee9fb6f571 + depends: + - c-compiler 1.7.0 hd590300_1 + - gxx + - gxx_linux-64 12.* + license: BSD-3-Clause + license_family: BSD + size: 6283 + timestamp: 1714575513327 +- kind: conda + name: cxx-compiler + version: 1.7.0 + build: h2ffa867_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.7.0-h2ffa867_1.conda + sha256: c07de4bdfcae8e0a589d360b79ae50f8f183fe698bc400b609c5e5d1f26e8b0f + md5: f75f0313233f50a6a58f7444a1c725a9 + depends: + - c-compiler 1.7.0 h6aa9301_1 + - clangxx_osx-arm64 16.* + license: BSD-3-Clause + license_family: BSD + size: 6442 + timestamp: 1714575634473 +- kind: conda + name: cxx-compiler + version: 1.7.0 + build: h7728843_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.7.0-h7728843_1.conda + sha256: 844b0894552468685c6a9f7eaab3837461e1ebea5c3880d8de616c83b618f044 + md5: e04cb15a20553b973dd068c2dc81d682 + depends: + - c-compiler 1.7.0 h282daa2_1 + - clangxx_osx-64 16.* + license: BSD-3-Clause + license_family: BSD + size: 6394 + timestamp: 1714575621870 +- kind: conda + name: cxx-compiler + version: 1.7.0 + build: h91493d7_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.7.0-h91493d7_1.conda + sha256: 2ad395bb14a26f69977b90617f344d4d4406625e839738c3f0418ee500121d96 + md5: 3ad688e50a39f7697a17783a1f42ffdd + depends: + - vs2019_win-64 + license: BSD-3-Clause + license_family: BSD + size: 6554 + timestamp: 1714575655901 +- kind: conda + name: gcc + version: 12.3.0 + build: h915e2ae_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gcc-12.3.0-h915e2ae_7.conda + sha256: 7358118791ddb5e1fb58fb0c52bf4b8b993817bae50f5bbf66677ce4df783fda + md5: 84b1c5cebd0a0443f3d7f90a4be93fc6 + depends: + - gcc_impl_linux-64 12.3.0.* + license: BSD-3-Clause + license_family: BSD + size: 25966 + timestamp: 1715016817964 +- kind: conda + name: gcc_impl_linux-64 + version: 12.3.0 + build: h58ffeeb_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-12.3.0-h58ffeeb_7.conda + sha256: a86af41f4b240ce86f05bc81cac1d10d272bc57e63ebab779aedc887e329e0c1 + md5: 95f78565a09852783d3e90e0389cfa5f + depends: + - binutils_impl_linux-64 >=2.40 + - libgcc-devel_linux-64 12.3.0 h0223996_107 + - libgcc-ng >=12.3.0 + - libgomp >=12.3.0 + - libsanitizer 12.3.0 hb8811af_7 + - libstdcxx-ng >=12.3.0 + - sysroot_linux-64 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 51128234 + timestamp: 1715016710479 +- kind: conda + name: gcc_linux-64 + version: 12.3.0 + build: h6477408_3 + build_number: 3 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-12.3.0-h6477408_3.conda + sha256: 836692c3d4948f25a19f9071db40f7788edcb342d771786a206a6a122f92365d + md5: 7a53f84c45bdf4656ba27b9e9ed68b3d + depends: + - binutils_linux-64 2.40 hdade7a5_3 + - gcc_impl_linux-64 12.3.0.* + - sysroot_linux-64 + license: BSD-3-Clause + license_family: BSD + size: 30977 + timestamp: 1710260096918 +- kind: conda + name: gxx + version: 12.3.0 + build: h915e2ae_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gxx-12.3.0-h915e2ae_7.conda + sha256: 81bba3a4a27cf8c8f29c31da2ebd2ec49899974d066ba20ce110ac1d067bfb78 + md5: 721c5433122a02bf3a081db10a2e68e2 + depends: + - gcc 12.3.0.* + - gxx_impl_linux-64 12.3.0.* + license: BSD-3-Clause + license_family: BSD + size: 25402 + timestamp: 1715017020869 +- kind: conda + name: gxx_impl_linux-64 + version: 12.3.0 + build: h2a574ab_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-12.3.0-h2a574ab_7.conda + sha256: c7a577846ae46dade05b7faa8956a7d4187b747bbc9be5c38a2b4ca8f7c108cc + md5: 265caa78b979f112fc241cecd0015c91 + depends: + - gcc_impl_linux-64 12.3.0 h58ffeeb_7 + - libstdcxx-devel_linux-64 12.3.0 h0223996_107 + - sysroot_linux-64 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 13036959 + timestamp: 1715016975232 +- kind: conda + name: gxx_linux-64 + version: 12.3.0 + build: h4a1b8e8_3 + build_number: 3 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-12.3.0-h4a1b8e8_3.conda + sha256: 5a842fc69c03ac513a2c021f3f21afd9d9ca50b10b95c0dcd236aa77d6d42373 + md5: 9ec22c7c544f4a4f6d660f0a3b0fd15c + depends: + - binutils_linux-64 2.40 hdade7a5_3 + - gcc_linux-64 12.3.0 h6477408_3 + - gxx_impl_linux-64 12.3.0.* + - sysroot_linux-64 + license: BSD-3-Clause + license_family: BSD + size: 29304 + timestamp: 1710260169322 +- kind: conda + name: icu + version: '73.2' + build: h59595ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/icu-73.2-h59595ed_0.conda + sha256: e12fd90ef6601da2875ebc432452590bc82a893041473bc1c13ef29001a73ea8 + md5: cc47e1facc155f91abd89b11e48e72ff + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT + size: 12089150 + timestamp: 1692900650789 +- kind: conda + name: icu + version: '73.2' + build: hc8870d7_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/icu-73.2-hc8870d7_0.conda + sha256: ff9cd0c6cd1349954c801fb443c94192b637e1b414514539f3c49c56a39f51b1 + md5: 8521bd47c0e11c5902535bb1a17c565f + license: MIT + license_family: MIT + size: 11997841 + timestamp: 1692902104771 +- kind: conda + name: icu + version: '73.2' + build: hf5e326d_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/icu-73.2-hf5e326d_0.conda + sha256: f66362dc36178ac9b7c7a9b012948a9d2d050b3debec24bbd94aadbc44854185 + md5: 5cc301d759ec03f28328428e28f65591 + license: MIT + license_family: MIT + size: 11787527 + timestamp: 1692901622519 +- kind: conda + name: kernel-headers_linux-64 + version: 2.6.32 + build: he073ed8_17 + build_number: 17 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-2.6.32-he073ed8_17.conda + sha256: fb39d64b48f3d9d1acc3df208911a41f25b6a00bd54935d5973b4739a9edd5b6 + md5: d731b543793afc0433c4fd593e693fce + constrains: + - sysroot_linux-64 ==2.12 + license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 + license_family: GPL + size: 710627 + timestamp: 1708000830116 +- kind: conda + name: keyutils + version: 1.6.1 + build: h166bdaf_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + sha256: 150c05a6e538610ca7c43beb3a40d65c90537497a4f6a5f4d15ec0451b6f5ebb + md5: 30186d27e2c9fa62b45fb1476b7200e3 + depends: + - libgcc-ng >=10.3.0 + license: LGPL-2.1-or-later + size: 117831 + timestamp: 1646151697040 +- kind: conda + name: krb5 + version: 1.21.2 + build: h659d440_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.2-h659d440_0.conda + sha256: 259bfaae731989b252b7d2228c1330ef91b641c9d68ff87dae02cbae682cb3e4 + md5: cd95826dbd331ed1be26bdf401432844 + depends: + - keyutils >=1.6.1,<2.0a0 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - openssl >=3.1.2,<4.0a0 + license: MIT + license_family: MIT + size: 1371181 + timestamp: 1692097755782 +- kind: conda + name: krb5 + version: 1.21.2 + build: h92f50d5_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.2-h92f50d5_0.conda + sha256: 70bdb9b4589ec7c7d440e485ae22b5a352335ffeb91a771d4c162996c3070875 + md5: 92f1cff174a538e0722bf2efb16fc0b2 + depends: + - libcxx >=15.0.7 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - openssl >=3.1.2,<4.0a0 + license: MIT + license_family: MIT + size: 1195575 + timestamp: 1692098070699 +- kind: conda + name: krb5 + version: 1.21.2 + build: hb884880_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.2-hb884880_0.conda + sha256: 081ae2008a21edf57c048f331a17c65d1ccb52d6ca2f87ee031a73eff4dc0fc6 + md5: 80505a68783f01dc8d7308c075261b2f + depends: + - libcxx >=15.0.7 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - openssl >=3.1.2,<4.0a0 + license: MIT + license_family: MIT + size: 1183568 + timestamp: 1692098004387 +- kind: conda + name: krb5 + version: 1.21.2 + build: heb0366b_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.2-heb0366b_0.conda + sha256: 6002adff9e3dcfc9732b861730cb9e33d45fd76b2035b2cdb4e6daacb8262c0b + md5: 6e8b0f22b4eef3b3cb3849bb4c3d47f9 + depends: + - openssl >=3.1.2,<4.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 710894 + timestamp: 1692098129546 +- kind: conda + name: ld64 + version: '711' + build: h634c8be_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-711-h634c8be_0.conda + sha256: bf1fa905f08aa2044d5ca9a387c4d626c1b92a81773665268e87cf03a4db1159 + md5: 5fb1c87739bf8f52d36cb001248e29b6 + depends: + - ld64_osx-arm64 711 ha4bd21c_0 + - libllvm16 >=16.0.6,<16.1.0a0 + constrains: + - cctools 986.* + - cctools_osx-arm64 986.* + license: APSL-2.0 + license_family: Other + size: 18884 + timestamp: 1710466784602 +- kind: conda + name: ld64 + version: '711' + build: ha02d983_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ld64-711-ha02d983_0.conda + sha256: 189f5a0f9f923ee7f165fd9f18633ffa5680c24118d731c0a9956ac21dd42720 + md5: 3ae4930ec076735cce481e906f5192e0 + depends: + - ld64_osx-64 711 ha20a434_0 + - libllvm16 >=16.0.6,<16.1.0a0 + constrains: + - cctools 986.* + - cctools_osx-64 986.* + license: APSL-2.0 + license_family: Other + size: 18819 + timestamp: 1710466446391 +- kind: conda + name: ld64_osx-64 + version: '711' + build: ha20a434_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-711-ha20a434_0.conda + sha256: 8c4cdd119ff4d8c83f6ae044c76560be302e4986ec1d5f278943ed9319f1171c + md5: a8b41eb97c8a9d618243a79ba78fdc3c + depends: + - libcxx + - libllvm16 >=16.0.6,<16.1.0a0 + - sigtool + - tapi >=1100.0.11,<1101.0a0 + constrains: + - clang >=16.0.6,<17.0a0 + - cctools 986.* + - ld 711.* + - cctools_osx-64 986.* + license: APSL-2.0 + license_family: Other + size: 1075550 + timestamp: 1710466354788 +- kind: conda + name: ld64_osx-arm64 + version: '711' + build: ha4bd21c_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-711-ha4bd21c_0.conda + sha256: f27b661fa4cac5b351ed4ee0ec8c8baf27c2f982309a453968418438c8197450 + md5: 38abda2ba1128fdde7b7108cc36a9d99 + depends: + - libcxx + - libllvm16 >=16.0.6,<16.1.0a0 + - sigtool + - tapi >=1100.0.11,<1101.0a0 + constrains: + - ld 711.* + - clang >=16.0.6,<17.0a0 + - cctools 986.* + - cctools_osx-arm64 986.* + license: APSL-2.0 + license_family: Other + size: 1066358 + timestamp: 1710466668466 +- kind: conda + name: ld_impl_linux-64 + version: '2.40' + build: hf3520f5_2 + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.40-hf3520f5_2.conda + sha256: 5ed96807b26bc32d2d180e38e7340388ddfdb642950f888f7da78d274846afea + md5: 61b0bd5219ce7192b4e3633521a78975 + constrains: + - binutils_impl_linux-64 2.40 + license: GPL-3.0-only + license_family: GPL + size: 708179 + timestamp: 1717523002366 +- kind: conda + name: libclang-cpp16 + version: 16.0.6 + build: default_h4c8afb6_7 + build_number: 7 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp16-16.0.6-default_h4c8afb6_7.conda + sha256: a3ca75f5311308d62a732b9a3f8307b5f0e39303fa7e857dcdd247e0bae2aeb7 + md5: 784816790fe438443354d13050fcd67d + depends: + - __osx >=10.13 + - libcxx >=16.0.6 + - libllvm16 >=16.0.6,<16.1.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 12861346 + timestamp: 1716980259803 +- kind: conda + name: libclang-cpp16 + version: 16.0.6 + build: default_hb63da90_7 + build_number: 7 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp16-16.0.6-default_hb63da90_7.conda + sha256: 613a2a670d7448b0c16971172dc060e7c32a22a63fc11f65cd90d4e70d3b7a74 + md5: 3753e98f8145f5f9b3bfe27575ec3c3a + depends: + - __osx >=11.0 + - libcxx >=16.0.6 + - libllvm16 >=16.0.6,<16.1.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 11912321 + timestamp: 1716980622468 +- kind: conda + name: libclang-cpp18.1 + version: 18.1.6 + build: default_h127d8a8_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp18.1-18.1.6-default_h127d8a8_0.conda + sha256: 6b7a3179553288d714958cfbcdbc1654f807d6c1f1a7e2081d9f23eb170424e9 + md5: d681ec78d41c1529934e0fc16614e5c8 + depends: + - libgcc-ng >=12 + - libllvm18 >=18.1.6,<18.2.0a0 + - libstdcxx-ng >=12 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 19270332 + timestamp: 1716714630714 +- kind: conda + name: libclang-cpp18.1 + version: 18.1.6 + build: default_h7c89ad4_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.6-default_h7c89ad4_0.conda + sha256: b269c6ca8d28b5ca0eaa869b829fb5e8efe71085938eb759a62170dfba7f4dbb + md5: 6b081c3b22144317ad58aad7f93dd25a + depends: + - libcxx >=16.0.6 + - libllvm18 >=18.1.6,<18.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 12913697 + timestamp: 1716712990417 +- kind: conda + name: libclang-cpp18.1 + version: 18.1.6 + build: default_ha3b9224_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.6-default_ha3b9224_0.conda + sha256: 51b2c33c66f1d350a43139e380026ca9e07996cde5e7773d946cc1d539ad23dc + md5: 9ac0e952bb9f1b281ac415190eb88ff6 + depends: + - libcxx >=16.0.6 + - libllvm18 >=18.1.6,<18.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 13776066 + timestamp: 1716712637323 +- kind: conda + name: libcurl + version: 8.8.0 + build: h7b6f9a7_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.8.0-h7b6f9a7_0.conda + sha256: b83aa249e7c8abc1aa56593ad50d1b4c0a52f5f3d5fd7c489c2ccfc3a548f391 + md5: 245b30f99dc5379ebe1c78899be8d3f5 + depends: + - krb5 >=1.21.2,<1.22.0a0 + - libnghttp2 >=1.58.0,<2.0a0 + - libssh2 >=1.11.0,<2.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.3.0,<4.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: curl + license_family: MIT + size: 364890 + timestamp: 1716378993833 +- kind: conda + name: libcurl + version: 8.8.0 + build: hca28451_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.8.0-hca28451_0.conda + sha256: 45aec0ffc6fe3fd4c0083b815aa102b8103380acc2b6714fb272d921acc68ab2 + md5: f21c27f076a07907e70c49bb57bd0f20 + depends: + - krb5 >=1.21.2,<1.22.0a0 + - libgcc-ng >=12 + - libnghttp2 >=1.58.0,<2.0a0 + - libssh2 >=1.11.0,<2.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.3.0,<4.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: curl + license_family: MIT + size: 405535 + timestamp: 1716378550673 +- kind: conda + name: libcurl + version: 8.8.0 + build: hd5e4a3a_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.8.0-hd5e4a3a_0.conda + sha256: 169fb0a11dd3a1f0adbb93b275f9752aa24b64e73d0c8e220aa10213c6ee74ff + md5: 4f86149dc6228f1e5617faa2cce90f94 + depends: + - krb5 >=1.21.2,<1.22.0a0 + - libssh2 >=1.11.0,<2.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: curl + license_family: MIT + size: 334903 + timestamp: 1716379079949 +- kind: conda + name: libcurl + version: 8.8.0 + build: hf9fcc65_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.8.0-hf9fcc65_0.conda + sha256: 1eb3e00586ddbf662877e62d1108bd2ff539fbeee34c52edf1d6c5fa3c9f4435 + md5: 276894efcbca23aa674e280e90bc5673 + depends: + - krb5 >=1.21.2,<1.22.0a0 + - libnghttp2 >=1.58.0,<2.0a0 + - libssh2 >=1.11.0,<2.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.3.0,<4.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: curl + license_family: MIT + size: 385778 + timestamp: 1716378974624 +- kind: conda + name: libcxx + version: 17.0.6 + build: h5f092b4_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-17.0.6-h5f092b4_0.conda + sha256: 119d3d9306f537d4c89dc99ed99b94c396d262f0b06f7833243646f68884f2c2 + md5: a96fd5dda8ce56c86a971e0fa02751d0 + depends: + - __osx >=11.0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 1248885 + timestamp: 1715020154867 +- kind: conda + name: libcxx + version: 17.0.6 + build: h88467a6_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libcxx-17.0.6-h88467a6_0.conda + sha256: e7b57062c1edfcbd13d2129467c94cbff7f0a988ee75782bf48b1dc0e6300b8b + md5: 0fe355aecb8d24b8bc07c763209adbd9 + depends: + - __osx >=10.13 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 1249309 + timestamp: 1715020018902 +- kind: conda + name: libedit + version: 3.1.20191231 + build: h0678c8f_2 + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20191231-h0678c8f_2.tar.bz2 + sha256: dbd3c3f2eca1d21c52e4c03b21930bbce414c4592f8ce805801575b9e9256095 + md5: 6016a8a1d0e63cac3de2c352cd40208b + depends: + - ncurses >=6.2,<7.0.0a0 + license: BSD-2-Clause + license_family: BSD + size: 105382 + timestamp: 1597616576726 +- kind: conda + name: libedit + version: 3.1.20191231 + build: hc8eb9b7_2 + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20191231-hc8eb9b7_2.tar.bz2 + sha256: 3912636197933ecfe4692634119e8644904b41a58f30cad9d1fc02f6ba4d9fca + md5: 30e4362988a2623e9eb34337b83e01f9 + depends: + - ncurses >=6.2,<7.0.0a0 + license: BSD-2-Clause + license_family: BSD + size: 96607 + timestamp: 1597616630749 +- kind: conda + name: libedit + version: 3.1.20191231 + build: he28a2e2_2 + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2 + sha256: a57d37c236d8f7c886e01656f4949d9dcca131d2a0728609c6f7fa338b65f1cf + md5: 4d331e44109e3f0e19b4cb8f9b82f3e1 + depends: + - libgcc-ng >=7.5.0 + - ncurses >=6.2,<7.0.0a0 + license: BSD-2-Clause + license_family: BSD + size: 123878 + timestamp: 1597616541093 +- kind: conda + name: libev + version: '4.33' + build: h10d778d_2 + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda + sha256: 0d238488564a7992942aa165ff994eca540f687753b4f0998b29b4e4d030ff43 + md5: 899db79329439820b7e8f8de41bca902 + license: BSD-2-Clause + license_family: BSD + size: 106663 + timestamp: 1702146352558 +- kind: conda + name: libev + version: '4.33' + build: h93a5062_2 + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda + sha256: 95cecb3902fbe0399c3a7e67a5bed1db813e5ab0e22f4023a5e0f722f2cc214f + md5: 36d33e440c31857372a72137f78bacf5 + license: BSD-2-Clause + license_family: BSD + size: 107458 + timestamp: 1702146414478 +- kind: conda + name: libev + version: '4.33' + build: hd590300_2 + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda + sha256: 1cd6048169fa0395af74ed5d8f1716e22c19a81a8a36f934c110ca3ad4dd27b4 + md5: 172bf1cd1ff8629f2b1179945ed45055 + depends: + - libgcc-ng >=12 + license: BSD-2-Clause + license_family: BSD + size: 112766 + timestamp: 1702146165126 +- kind: conda + name: libexpat + version: 2.6.2 + build: h59595ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.2-h59595ed_0.conda + sha256: 331bb7c7c05025343ebd79f86ae612b9e1e74d2687b8f3179faec234f986ce19 + md5: e7ba12deb7020dd080c6c70e7b6f6a3d + depends: + - libgcc-ng >=12 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 73730 + timestamp: 1710362120304 +- kind: conda + name: libexpat + version: 2.6.2 + build: h63175ca_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.6.2-h63175ca_0.conda + sha256: 79f612f75108f3e16bbdc127d4885bb74729cf66a8702fca0373dad89d40c4b7 + md5: bc592d03f62779511d392c175dcece64 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 139224 + timestamp: 1710362609641 +- kind: conda + name: libexpat + version: 2.6.2 + build: h73e2aa4_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.2-h73e2aa4_0.conda + sha256: a188a77b275d61159a32ab547f7d17892226e7dac4518d2c6ac3ac8fc8dfde92 + md5: 3d1d51c8f716d97c864d12f7af329526 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 69246 + timestamp: 1710362566073 +- kind: conda + name: libexpat + version: 2.6.2 + build: hebf3989_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.6.2-hebf3989_0.conda + sha256: ba7173ac30064ea901a4c9fb5a51846dcc25512ceb565759be7d18cbf3e5415e + md5: e3cde7cfa87f82f7cb13d482d5e0ad09 + constrains: + - expat 2.6.2.* + license: MIT + license_family: MIT + size: 63655 + timestamp: 1710362424980 +- kind: conda + name: libgcc-devel_linux-64 + version: 12.3.0 + build: h0223996_107 + build_number: 107 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-12.3.0-h0223996_107.conda + sha256: d6623e46608ef1baf2baa14ac77d0aefbc5187f1b9b5423592bfa124054e6753 + md5: 851e9651c9e4cd5dc19f80398eba9a1c + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 2532549 + timestamp: 1715016464312 +- kind: conda + name: libgcc-ng + version: 13.2.0 + build: h77fa898_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.2.0-h77fa898_7.conda + sha256: 62af2b89acbe74a21606c8410c276e57309c0a2ab8a9e8639e3c8131c0b60c92 + md5: 72ec1b1b04c4d15d4204ece1ecea5978 + depends: + - _libgcc_mutex 0.1 conda_forge + - _openmp_mutex >=4.5 + constrains: + - libgomp 13.2.0 h77fa898_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 775806 + timestamp: 1715016057793 +- kind: conda + name: libgomp + version: 13.2.0 + build: h77fa898_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.2.0-h77fa898_7.conda + sha256: 781444fa069d3b50e8ed667b750571cacda785761c7fc2a89ece1ac49693d4ad + md5: abf3fec87c2563697defa759dec3d639 + depends: + - _libgcc_mutex 0.1 conda_forge + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 422336 + timestamp: 1715015995979 +- kind: conda + name: libiconv + version: '1.17' + build: h0d3ecfb_2 + build_number: 2 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.17-h0d3ecfb_2.conda + sha256: bc7de5097b97bcafcf7deaaed505f7ce02f648aac8eccc0d5a47cc599a1d0304 + md5: 69bda57310071cf6d2b86caf11573d2d + license: LGPL-2.1-only + size: 676469 + timestamp: 1702682458114 +- kind: conda + name: libiconv + version: '1.17' + build: hd590300_2 + build_number: 2 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.17-hd590300_2.conda + sha256: 8ac2f6a9f186e76539439e50505d98581472fedb347a20e7d1f36429849f05c9 + md5: d66573916ffcf376178462f1b61c941e + depends: + - libgcc-ng >=12 + license: LGPL-2.1-only + size: 705775 + timestamp: 1702682170569 +- kind: conda + name: libiconv + version: '1.17' + build: hd75f5a5_2 + build_number: 2 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.17-hd75f5a5_2.conda + sha256: 23d4923baeca359423a7347c2ed7aaf48c68603df0cf8b87cc94a10b0d4e9a23 + md5: 6c3628d047e151efba7cf08c5e54d1ca + license: LGPL-2.1-only + size: 666538 + timestamp: 1702682713201 +- kind: conda + name: libllvm16 + version: 16.0.6 + build: haab561b_3 + build_number: 3 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm16-16.0.6-haab561b_3.conda + sha256: f240f3776b02c39a32ce7397d6f2de072510321c835f4def452fc62e5c3babc0 + md5: 9900d62ede9ce25b569beeeab1da094e + depends: + - libcxx >=16 + - libxml2 >=2.12.1,<3.0.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - zstd >=1.5.5,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 23347663 + timestamp: 1701374993634 +- kind: conda + name: libllvm16 + version: 16.0.6 + build: hbedff68_3 + build_number: 3 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libllvm16-16.0.6-hbedff68_3.conda + sha256: ad848dc0bb02b1dbe54324ee5700b050a2e5f63c095f5229b2de58249a3e268e + md5: 8fd56c0adc07a37f93bd44aa61a97c90 + depends: + - libcxx >=16 + - libxml2 >=2.12.1,<3.0.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - zstd >=1.5.5,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 25196932 + timestamp: 1701379796962 +- kind: conda + name: libllvm18 + version: 18.1.6 + build: hb77312f_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libllvm18-18.1.6-hb77312f_0.conda + sha256: 0f529a258d0e586f4d443b5c4df9c36b1fcf5391d867e7e0a2b2cb6084337477 + md5: 1246fc4b9f4db452e69cc297967d4b3e + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libxml2 >=2.12.7,<3.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 38428999 + timestamp: 1716642164972 +- kind: conda + name: libllvm18 + version: 18.1.6 + build: hd5e122f_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.6-hd5e122f_0.conda + sha256: af0089345178401d2ca25105408f2a03d2972f0b07338d7623cbf304aa233b15 + md5: de6112a23c73bba1347886f65d16c2b6 + depends: + - __osx >=10.13 + - libcxx >=16 + - libxml2 >=2.12.7,<3.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 27571492 + timestamp: 1716631405049 +- kind: conda + name: libllvm18 + version: 18.1.6 + build: hdac5640_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.6-hdac5640_0.conda + sha256: d91ba61768a9830492081c6798619f8cf55552e7667b3fea141ad08dc77c0869 + md5: 0f810485b34dee7169728fa89b00683b + depends: + - __osx >=11.0 + - libcxx >=16 + - libxml2 >=2.12.7,<3.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 25766518 + timestamp: 1716632069769 +- kind: conda + name: libnghttp2 + version: 1.58.0 + build: h47da74e_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.58.0-h47da74e_1.conda + sha256: 1910c5306c6aa5bcbd623c3c930c440e9c77a5a019008e1487810e3c1d3716cb + md5: 700ac6ea6d53d5510591c4344d5c989a + depends: + - c-ares >=1.23.0,<2.0a0 + - libev >=4.33,<4.34.0a0 + - libev >=4.33,<5.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.0,<4.0a0 + license: MIT + license_family: MIT + size: 631936 + timestamp: 1702130036271 +- kind: conda + name: libnghttp2 + version: 1.58.0 + build: h64cf6d3_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.58.0-h64cf6d3_1.conda + sha256: 412fd768e787e586602f8e9ea52bf089f3460fc630f6987f0cbd89b70e9a4380 + md5: faecc55c2a8155d9ff1c0ff9a0fef64f + depends: + - __osx >=10.9 + - c-ares >=1.23.0,<2.0a0 + - libcxx >=16.0.6 + - libev >=4.33,<4.34.0a0 + - libev >=4.33,<5.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.0,<4.0a0 + license: MIT + license_family: MIT + size: 599736 + timestamp: 1702130398536 +- kind: conda + name: libnghttp2 + version: 1.58.0 + build: ha4dd798_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.58.0-ha4dd798_1.conda + sha256: fc97aaaf0c6d0f508be313d86c2705b490998d382560df24be918b8e977802cd + md5: 1813e066bfcef82de579a0be8a766df4 + depends: + - __osx >=10.9 + - c-ares >=1.23.0,<2.0a0 + - libcxx >=16.0.6 + - libev >=4.33,<4.34.0a0 + - libev >=4.33,<5.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.2.0,<4.0a0 + license: MIT + license_family: MIT + size: 565451 + timestamp: 1702130473930 +- kind: conda + name: libsanitizer + version: 12.3.0 + build: hb8811af_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-12.3.0-hb8811af_7.conda + sha256: 3f481da2367b5e407a954210b86a828528c0416023315a8d78e6729639c7d072 + md5: ee573415c47ce17f65101d0b3fba396d + depends: + - libgcc-ng >=12.3.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 3939615 + timestamp: 1715016598795 +- kind: conda + name: libssh2 + version: 1.11.0 + build: h0841786_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.0-h0841786_0.conda + sha256: 50e47fd9c4f7bf841a11647ae7486f65220cfc988ec422a4475fe8d5a823824d + md5: 1f5a58e686b13bcfde88b93f547d23fe + depends: + - libgcc-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.1.1,<4.0a0 + license: BSD-3-Clause + license_family: BSD + size: 271133 + timestamp: 1685837707056 +- kind: conda + name: libssh2 + version: 1.11.0 + build: h7a5bd25_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.0-h7a5bd25_0.conda + sha256: bb57d0c53289721fff1eeb3103a1c6a988178e88d8a8f4345b0b91a35f0e0015 + md5: 029f7dc931a3b626b94823bc77830b01 + depends: + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.1.1,<4.0a0 + license: BSD-3-Clause + license_family: BSD + size: 255610 + timestamp: 1685837894256 +- kind: conda + name: libssh2 + version: 1.11.0 + build: h7dfc565_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.0-h7dfc565_0.conda + sha256: 813fd04eed2a2d5d9c36e53c554f9c1f08e9324e2922bd60c9c52dbbed2dbcec + md5: dc262d03aae04fe26825062879141a41 + depends: + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.1.1,<4.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 266806 + timestamp: 1685838242099 +- kind: conda + name: libssh2 + version: 1.11.0 + build: hd019ec5_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.0-hd019ec5_0.conda + sha256: f3886763b88f4b24265db6036535ef77b7b77ce91b1cbe588c0fbdd861eec515 + md5: ca3a72efba692c59a90d4b9fc0dfe774 + depends: + - libzlib >=1.2.13,<2.0.0a0 + - openssl >=3.1.1,<4.0a0 + license: BSD-3-Clause + license_family: BSD + size: 259556 + timestamp: 1685837820566 +- kind: conda + name: libstdcxx-devel_linux-64 + version: 12.3.0 + build: h0223996_107 + build_number: 107 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-12.3.0-h0223996_107.conda + sha256: b67931a6ad04effddaf5b18c732ac6154f0f494d5d5189e5e23fbc5a26212389 + md5: 167a1f5d77d8f3c2a638f7eb418429f1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 11881031 + timestamp: 1715016519463 +- kind: conda + name: libstdcxx-ng + version: 13.2.0 + build: hc0a3c3a_7 + build_number: 7 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.2.0-hc0a3c3a_7.conda + sha256: 35f1e08be0a84810c9075f5bd008495ac94e6c5fe306dfe4b34546f11fed850f + md5: 53ebd4c833fa01cb2c6353e99f905406 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 3837704 + timestamp: 1715016117360 +- kind: conda + name: libuv + version: 1.48.0 + build: h67532ce_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.48.0-h67532ce_0.conda + sha256: fb87f7bfd464a3a841d23f418c86a206818da0c4346984392071d9342c9ea367 + md5: c8e7344c74f0d86584f7ecdc9f25c198 + license: MIT + license_family: MIT + size: 407040 + timestamp: 1709913680478 +- kind: conda + name: libuv + version: 1.48.0 + build: h93a5062_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.48.0-h93a5062_0.conda + sha256: 60bed2a7a85096387ab0381cbc32ea2da7f8dd99bd90e440983019c0cdd96ad1 + md5: abfd49e80f13453b62a56be226120ea8 + license: MIT + license_family: MIT + size: 405988 + timestamp: 1709913494015 +- kind: conda + name: libuv + version: 1.48.0 + build: hcfcfb64_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libuv-1.48.0-hcfcfb64_0.conda + sha256: 6151c51857c2407139ce22fdc956022353e675b2bc96991a9201d51cceaa90b4 + md5: 485e49e1d500d996844df14cabf64d73 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 289753 + timestamp: 1709913743184 +- kind: conda + name: libuv + version: 1.48.0 + build: hd590300_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.48.0-hd590300_0.conda + sha256: b7c0e8a0c93c2621be7645b37123d4e8d27e8a974da26a3fba47a9c37711aa7f + md5: 7e8b914b1062dd4386e3de4d82a3ead6 + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 899979 + timestamp: 1709913354710 +- kind: conda + name: libxml2 + version: 2.12.7 + build: h3e169fe_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.12.7-h3e169fe_1.conda + sha256: 75554b5ef4c61a97c1d2ddcaff2d87c5ee120ff6925c2b714e18b20727cafb98 + md5: ddb63049aa7bd9f08f2cdc5a1c144d1a + depends: + - __osx >=10.13 + - icu >=73.2,<74.0a0 + - libiconv >=1.17,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - xz >=5.2.6,<6.0a0 + license: MIT + license_family: MIT + size: 619297 + timestamp: 1717546472911 +- kind: conda + name: libxml2 + version: 2.12.7 + build: ha661575_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.12.7-ha661575_1.conda + sha256: 0ea12032b53d3767564a058ccd5208c0a1724ed2f8074dd22257ff3859ea6a4e + md5: 8ea71a74847498c793b0a8e9054a177a + depends: + - __osx >=11.0 + - icu >=73.2,<74.0a0 + - libiconv >=1.17,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - xz >=5.2.6,<6.0a0 + license: MIT + license_family: MIT + size: 588487 + timestamp: 1717546487246 +- kind: conda + name: libxml2 + version: 2.12.7 + build: hc051c1a_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.12.7-hc051c1a_1.conda + sha256: 576ea9134176636283ff052897bf7a91ffd8ac35b2c505dfde2890ec52849698 + md5: 340278ded8b0dc3a73f3660bbb0adbc6 + depends: + - icu >=73.2,<74.0a0 + - libgcc-ng >=12 + - libiconv >=1.17,<2.0a0 + - libzlib >=1.2.13,<2.0a0 + - xz >=5.2.6,<6.0a0 + license: MIT + license_family: MIT + size: 704984 + timestamp: 1717546454837 +- kind: conda + name: libzlib + version: 1.3.1 + build: h2466b09_1 + build_number: 1 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_1.conda + sha256: b13846a54a15243e15f96fec06b526d8155adc6a1ac2b6ed47a88f6a71a94b68 + md5: d4483ca8afc57ddf1f6dded53b36c17f + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 56186 + timestamp: 1716874730539 +- kind: conda + name: libzlib + version: 1.3.1 + build: h4ab18f5_1 + build_number: 1 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-h4ab18f5_1.conda + sha256: adf6096f98b537a11ae3729eaa642b0811478f0ea0402ca67b5108fe2cb0010d + md5: 57d7dc60e9325e3de37ff8dffd18e814 + depends: + - libgcc-ng >=12 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 61574 + timestamp: 1716874187109 +- kind: conda + name: libzlib + version: 1.3.1 + build: h87427d6_1 + build_number: 1 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-h87427d6_1.conda + sha256: 80a62db652b1da0ccc100812a1d86e94f75028968991bfb17f9536f3aa72d91d + md5: b7575b5aa92108dcc9aaab0f05f2dbce + depends: + - __osx >=10.13 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 57372 + timestamp: 1716874211519 +- kind: conda + name: libzlib + version: 1.3.1 + build: hfb2fe0b_1 + build_number: 1 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-hfb2fe0b_1.conda + sha256: c34365dd37b0eab27b9693af32a1f7f284955517c2cc91f1b88a7ef4738ff03e + md5: 636077128927cf79fd933276dc3aed47 + depends: + - __osx >=11.0 + constrains: + - zlib 1.3.1 *_1 + license: Zlib + license_family: Other + size: 46921 + timestamp: 1716874262512 +- kind: conda + name: llvm-openmp + version: 18.1.6 + build: h15ab845_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-18.1.6-h15ab845_0.conda + sha256: b07be564a0539adc6f6e12b921469c925b37799e50a27a9dbe276115e9de689a + md5: 065f974bc7afcef3f94df56394e16154 + depends: + - __osx >=10.13 + constrains: + - openmp 18.1.6|18.1.6.* + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 300479 + timestamp: 1716753668057 +- kind: conda + name: llvm-openmp + version: 18.1.6 + build: hde57baf_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-18.1.6-hde57baf_0.conda + sha256: ca646e5d47040fb63bec903c3af7b5a9888d58c8cc2acb424e1dd48f9fa4532d + md5: f4565f7e5ce486f33705ff6bfc586688 + depends: + - __osx >=11.0 + constrains: + - openmp 18.1.6|18.1.6.* + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 276591 + timestamp: 1716753686325 +- kind: conda + name: llvm-tools + version: 16.0.6 + build: haab561b_3 + build_number: 3 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-16.0.6-haab561b_3.conda + sha256: 64cc3547a2b0a3700a9fa0bd1fd3258156900b48ae73fc1a4b391002ca1462bf + md5: ca8e3771122c520fbe72af7c83d6d4cd + depends: + - libllvm16 16.0.6 haab561b_3 + - libxml2 >=2.12.1,<3.0.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - zstd >=1.5.5,<1.6.0a0 + constrains: + - llvmdev 16.0.6 + - clang 16.0.6.* + - clang-tools 16.0.6.* + - llvm 16.0.6.* + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 20685770 + timestamp: 1701375136405 +- kind: conda + name: llvm-tools + version: 16.0.6 + build: hbedff68_3 + build_number: 3 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-16.0.6-hbedff68_3.conda + sha256: dff3ca83c6945f020ee6d3c62ddb3ed175ae8a357be3689a8836bcfe25ad9882 + md5: e9356b0807462e8f84c1384a8da539a5 + depends: + - libllvm16 16.0.6 hbedff68_3 + - libxml2 >=2.12.1,<3.0.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - zstd >=1.5.5,<1.6.0a0 + constrains: + - llvmdev 16.0.6 + - clang 16.0.6.* + - clang-tools 16.0.6.* + - llvm 16.0.6.* + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 22221159 + timestamp: 1701379965425 +- kind: conda + name: ncurses + version: '6.5' + build: h5846eda_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h5846eda_0.conda + sha256: 6ecc73db0e49143092c0934355ac41583a5d5a48c6914c5f6ca48e562d3a4b79 + md5: 02a888433d165c99bf09784a7b14d900 + license: X11 AND BSD-3-Clause + size: 823601 + timestamp: 1715195267791 +- kind: conda + name: ncurses + version: '6.5' + build: h59595ed_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h59595ed_0.conda + sha256: 4fc3b384f4072b68853a0013ea83bdfd3d66b0126e2238e1d6e1560747aa7586 + md5: fcea371545eda051b6deafb24889fc69 + depends: + - libgcc-ng >=12 + license: X11 AND BSD-3-Clause + size: 887465 + timestamp: 1715194722503 +- kind: conda + name: ncurses + version: '6.5' + build: hb89a1cb_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-hb89a1cb_0.conda + sha256: 87d7cf716d9d930dab682cb57b3b8d3a61940b47d6703f3529a155c938a6990a + md5: b13ad5724ac9ae98b6b4fd87e4500ba4 + license: X11 AND BSD-3-Clause + size: 795131 + timestamp: 1715194898402 +- kind: conda + name: ninja + version: 1.12.1 + build: h297d8ca_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.12.1-h297d8ca_0.conda + sha256: 40f7b76b07067935f8a5886aab0164067b7aa71eb5ad20b7278618c0c2c98e06 + md5: 3aa1c7e292afeff25a0091ddd7c69b72 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: Apache-2.0 + license_family: Apache + size: 2198858 + timestamp: 1715440571685 +- kind: conda + name: ninja + version: 1.12.1 + build: h3c5361c_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.12.1-h3c5361c_0.conda + sha256: 230f11a2f73955b67550be09a0c1fd053772f5e01e98d5873547d63ebea73229 + md5: a0ebabd021c8191aeb82793fe43cfdcb + depends: + - __osx >=10.13 + - libcxx >=16 + license: Apache-2.0 + license_family: Apache + size: 124942 + timestamp: 1715440780183 +- kind: conda + name: ninja + version: 1.12.1 + build: h420ef59_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.12.1-h420ef59_0.conda + sha256: 11528acfa0f05d0c51639f6b09b51dc6611b801668449bb36c206c4b055be4f4 + md5: 9166c10405d41c95ffde8fcb8e5c3d51 + depends: + - __osx >=11.0 + - libcxx >=16 + license: Apache-2.0 + license_family: Apache + size: 112576 + timestamp: 1715440927034 +- kind: conda + name: ninja + version: 1.12.1 + build: hc790b64_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ninja-1.12.1-hc790b64_0.conda + sha256: b821cb72cb3ef08fab90a9bae899510e6cf3c23b5da6070d1ec30099dfe6a5be + md5: a557dde55343e03c68cd7e29e7f87279 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: Apache-2.0 + license_family: Apache + size: 285150 + timestamp: 1715441052517 +- kind: conda + name: openssl + version: 3.3.1 + build: h2466b09_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/openssl-3.3.1-h2466b09_0.conda + sha256: fbd63a41b854370a74e5f7ccc50d67f053d60c08e40389156e7924df0824d297 + md5: 27fe798366ef3a81715b13eedf699e2f + depends: + - ca-certificates + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 8383610 + timestamp: 1717550042871 +- kind: conda + name: openssl + version: 3.3.1 + build: h4ab18f5_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.3.1-h4ab18f5_0.conda + sha256: 9691f8bd6394c5bb0b8d2f47cd1467b91bd5b1df923b69e6b517f54496ee4b50 + md5: a41fa0e391cc9e0d6b78ac69ca047a6c + depends: + - ca-certificates + - libgcc-ng >=12 + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 2896170 + timestamp: 1717546157673 +- kind: conda + name: openssl + version: 3.3.1 + build: h87427d6_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.3.1-h87427d6_0.conda + sha256: 272bee725877f417fef923f5e7852ebfe06b40b6bf3364f4498b2b3f568d5e2c + md5: 1bdad93ae01353340f194c5d879745db + depends: + - __osx >=10.13 + - ca-certificates + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 2547614 + timestamp: 1717546605131 +- kind: conda + name: openssl + version: 3.3.1 + build: hfb2fe0b_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.3.1-hfb2fe0b_0.conda + sha256: 6cb2d44f027b259be8cba2240bdf21af7b426e4132a73e0052f7173ab8b60ab0 + md5: c4a0bbd96a0da60bf265dac62c87f4e1 + depends: + - __osx >=11.0 + - ca-certificates + constrains: + - pyopenssl >=22.1 + license: Apache-2.0 + license_family: Apache + size: 2891941 + timestamp: 1717545846389 +- kind: conda + name: rhash + version: 1.4.4 + build: h0dc2134_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.4-h0dc2134_0.conda + sha256: f1ae47e8c4e46f856faf5d8ee1e5291f55627aa93401b61a877f18ade5780c87 + md5: 55a2ada70c8a208c01f77978f2783121 + license: MIT + license_family: MIT + size: 177229 + timestamp: 1693456080514 +- kind: conda + name: rhash + version: 1.4.4 + build: hb547adb_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.4-hb547adb_0.conda + sha256: 3ab595e2280ed2118b6b1e8ce7e5949da2047846c81b6af1bbf5ac859d062edd + md5: 710c4b1abf65b697c1d9716eba16dbb0 + license: MIT + license_family: MIT + size: 177491 + timestamp: 1693456037505 +- kind: conda + name: rhash + version: 1.4.4 + build: hd590300_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.4-hd590300_0.conda + sha256: 12711d2d4a808a503c2e49b25d26ecb351435521e814c154e682dd2be71c2611 + md5: ec972a9a2925ac8d7a19eb9606561fff + depends: + - libgcc-ng >=12 + license: MIT + license_family: MIT + size: 185144 + timestamp: 1693455923632 +- kind: conda + name: rust + version: 1.75.0 + build: h4ff7c5d_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/rust-1.75.0-h4ff7c5d_0.conda + sha256: 8bd35dcc0e9761d7f02500ed907e6ee8992c3549250361e40ff5016f84cef215 + md5: 12b6a710ed0f1f366fedbf9d69b7b277 + depends: + - rust-std-aarch64-apple-darwin 1.75.0 hf6ec828_0 + license: MIT + license_family: MIT + size: 181697449 + timestamp: 1704208767306 +- kind: conda + name: rust + version: 1.75.0 + build: h70c747d_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/rust-1.75.0-h70c747d_0.conda + sha256: 5de27c76796ce0dd0ef7496f7c7f9c33a4e4cfa59112f8a1d7b2ada41794609a + md5: d2112c5913c6a3741eecff0c3ab02e7e + depends: + - gcc_impl_linux-64 + - libgcc-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + - rust-std-x86_64-unknown-linux-gnu 1.75.0 h2c6d0dc_0 + license: MIT + license_family: MIT + size: 190432074 + timestamp: 1704209051045 +- kind: conda + name: rust + version: 1.75.0 + build: h7e1429e_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/rust-1.75.0-h7e1429e_0.conda + sha256: 715783725eb9f5689bf57dda8eff8ca85df8940336129e82a836ab8e10aefae1 + md5: 21ab11c8f798546e46f023093f650866 + depends: + - rust-std-x86_64-apple-darwin 1.75.0 h38e4360_0 + license: MIT + license_family: MIT + size: 191324119 + timestamp: 1704208696296 +- kind: conda + name: rust + version: 1.75.0 + build: hf8d6059_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/rust-1.75.0-hf8d6059_0.conda + sha256: bb0e39570b63bf10c859afcc1593c41d4e9b164e63f78835403f79cbb3145d4d + md5: 68ac0e9721e34c115201a76c63bd82c8 + depends: + - rust-std-x86_64-pc-windows-msvc 1.75.0 h17fc481_0 + license: MIT + license_family: MIT + size: 186456319 + timestamp: 1704211980549 +- kind: conda + name: rust-std-aarch64-apple-darwin + version: 1.75.0 + build: hf6ec828_0 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/rust-std-aarch64-apple-darwin-1.75.0-hf6ec828_0.conda + sha256: 19d2d1247e239c204352e4419f8a35a5abe2b9ec1e02c151ac611c2d50f2edab + md5: dd34d3d31a2b900e59582e8616bdeca8 + depends: + - __unix + constrains: + - rust >=1.75.0,<1.75.1.0a0 + license: MIT + license_family: MIT + size: 29617229 + timestamp: 1704208512989 +- kind: conda + name: rust-std-x86_64-apple-darwin + version: 1.75.0 + build: h38e4360_0 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-apple-darwin-1.75.0-h38e4360_0.conda + sha256: bbcbb5f8643dd61605f6edb6487b18497511669267091f578b29e4902ccb421c + md5: ddfe0984ccdd936ee23ce8b0c4c88d6a + depends: + - __unix + constrains: + - rust >=1.75.0,<1.75.1.0a0 + license: MIT + license_family: MIT + size: 30638012 + timestamp: 1704208441871 +- kind: conda + name: rust-std-x86_64-pc-windows-msvc + version: 1.75.0 + build: h17fc481_0 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-pc-windows-msvc-1.75.0-h17fc481_0.conda + sha256: e7f62368332a48b8c7b44e27204cbf6c6d71fd433f6d7a24c20dacd623557503 + md5: 376e875d5c8e957a3ef44d24eff109eb + depends: + - __win + constrains: + - rust >=1.75.0,<1.75.1.0a0 + license: MIT + license_family: MIT + size: 24987788 + timestamp: 1704211520005 +- kind: conda + name: rust-std-x86_64-unknown-linux-gnu + version: 1.75.0 + build: h2c6d0dc_0 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/rust-std-x86_64-unknown-linux-gnu-1.75.0-h2c6d0dc_0.conda + sha256: 4ae02c3fadece8b4c0b0a214f21b4fd8e47ec81a332c503fdd21a659a472f108 + md5: 46ab571e9b711ed713cd515395d187dd + depends: + - __unix + constrains: + - rust >=1.75.0,<1.75.1.0a0 + license: MIT + license_family: MIT + size: 33042935 + timestamp: 1704208890522 +- kind: conda + name: sigtool + version: 0.1.3 + build: h44b9a77_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-0.1.3-h44b9a77_0.tar.bz2 + sha256: 70791ae00a3756830cb50451db55f63e2a42a2fa2a8f1bab1ebd36bbb7d55bff + md5: 4a2cac04f86a4540b8c9b8d8f597848f + depends: + - openssl >=3.0.0,<4.0a0 + license: MIT + license_family: MIT + size: 210264 + timestamp: 1643442231687 +- kind: conda + name: sigtool + version: 0.1.3 + build: h88f4db0_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/sigtool-0.1.3-h88f4db0_0.tar.bz2 + sha256: 46fdeadf8f8d725819c4306838cdfd1099cd8fe3e17bd78862a5dfdcd6de61cf + md5: fbfb84b9de9a6939cb165c02c69b1865 + depends: + - openssl >=3.0.0,<4.0a0 + license: MIT + license_family: MIT + size: 213817 + timestamp: 1643442169866 +- kind: conda + name: sysroot_linux-64 + version: '2.12' + build: he073ed8_17 + build_number: 17 + subdir: noarch + noarch: generic + url: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.12-he073ed8_17.conda + sha256: b4e4d685e41cb36cfb16f0cb15d2c61f8f94f56fab38987a44eff95d8a673fb5 + md5: 595db67e32b276298ff3d94d07d47fbf + depends: + - kernel-headers_linux-64 2.6.32 he073ed8_17 + license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 + license_family: GPL + size: 15127123 + timestamp: 1708000843849 +- kind: conda + name: tapi + version: 1100.0.11 + build: h9ce4665_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/tapi-1100.0.11-h9ce4665_0.tar.bz2 + sha256: 34b18ce8d1518b67e333ca1d3af733c3976ecbdf3a36b727f9b4dedddcc588fa + md5: f9ff42ccf809a21ba6f8607f8de36108 + depends: + - libcxx >=10.0.0.a0 + license: NCSA + license_family: MIT + size: 201044 + timestamp: 1602664232074 +- kind: conda + name: tapi + version: 1100.0.11 + build: he4954df_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1100.0.11-he4954df_0.tar.bz2 + sha256: 1709265fbee693a9e8b4126b0a3e68a6c4718b05821c659279c1af051f2d40f3 + md5: d83362e7d0513f35f454bc50b0ca591d + depends: + - libcxx >=11.0.0.a0 + license: NCSA + license_family: MIT + size: 191416 + timestamp: 1602687595316 +- kind: conda + name: ucrt + version: 10.0.22621.0 + build: h57928b3_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_0.tar.bz2 + sha256: f29cdaf8712008f6b419b8b1a403923b00ab2504bfe0fb2ba8eb60e72d4f14c6 + md5: 72608f6cd3e5898229c3ea16deb1ac43 + constrains: + - vs2015_runtime >=14.29.30037 + license: LicenseRef-Proprietary + license_family: PROPRIETARY + size: 1283972 + timestamp: 1666630199266 +- kind: conda + name: vc + version: '14.3' + build: ha32ba9b_20 + build_number: 20 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-ha32ba9b_20.conda + sha256: 16cb562ce210ee089060f4aa52f3225a571c83885632a870ea2297d460e3bb00 + md5: 2abfb5cb1b9d41a50f765d60f0be563d + depends: + - vc14_runtime >=14.38.33135 + track_features: + - vc14 + license: BSD-3-Clause + license_family: BSD + size: 17122 + timestamp: 1716231244564 +- kind: conda + name: vc14_runtime + version: 14.38.33135 + build: h835141b_20 + build_number: 20 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.38.33135-h835141b_20.conda + sha256: 05b07e0dd3fd49dcc98a365ff661ed6b65e2f0266b4bb03d273131ffdba663be + md5: e971b35a5765862fabc4ba6e5ddf9470 + depends: + - ucrt >=10.0.20348.0 + constrains: + - vs2015_runtime 14.38.33135.* *_20 + license: LicenseRef-ProprietaryMicrosoft + license_family: Proprietary + size: 744189 + timestamp: 1716231234745 +- kind: conda + name: vs2015_runtime + version: 14.38.33135 + build: h22015db_20 + build_number: 20 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.38.33135-h22015db_20.conda + sha256: 2cebabc39766ea051e577762d813ad4151e9d0ff96f3ff3374d575a272951416 + md5: bb4f5ab332e46e1b022d8842e72905b1 + depends: + - vc14_runtime >=14.38.33135 + license: BSD-3-Clause + license_family: BSD + size: 17124 + timestamp: 1716231247457 +- kind: conda + name: vs2019_win-64 + version: 19.29.30139 + build: he1865b1_20 + build_number: 20 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/vs2019_win-64-19.29.30139-he1865b1_20.conda + sha256: b9b3faf4fa20301ad1886cfde20d339ea6c2e95de8f4710e0b49af1ca1d3a657 + md5: bc2f92e632f5c6b0d94e365546c7fc6e + depends: + - vswhere + constrains: + - vs_win-64 2019.11 + track_features: + - vc14 + license: BSD-3-Clause + license_family: BSD + size: 19744 + timestamp: 1716231200159 +- kind: conda + name: vswhere + version: 3.1.4 + build: h57928b3_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/vswhere-3.1.4-h57928b3_0.conda + sha256: 553c41fc1a883415a39444313f8d99236685529776fdd04e8d97288b73496002 + md5: b1d1d6a1f874d8c93a57b5efece52f03 + license: MIT + license_family: MIT + size: 218421 + timestamp: 1682376911339 +- kind: conda + name: xz + version: 5.2.6 + build: h166bdaf_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2 + sha256: 03a6d28ded42af8a347345f82f3eebdd6807a08526d47899a42d62d319609162 + md5: 2161070d867d1b1204ea749c8eec4ef0 + depends: + - libgcc-ng >=12 + license: LGPL-2.1 and GPL-2.0 + size: 418368 + timestamp: 1660346797927 +- kind: conda + name: xz + version: 5.2.6 + build: h57fd34a_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/xz-5.2.6-h57fd34a_0.tar.bz2 + sha256: 59d78af0c3e071021cfe82dc40134c19dab8cdf804324b62940f5c8cd71803ec + md5: 39c6b54e94014701dd157f4f576ed211 + license: LGPL-2.1 and GPL-2.0 + size: 235693 + timestamp: 1660346961024 +- kind: conda + name: xz + version: 5.2.6 + build: h775f41a_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/xz-5.2.6-h775f41a_0.tar.bz2 + sha256: eb09823f34cc2dd663c0ec4ab13f246f45dcd52e5b8c47b9864361de5204a1c8 + md5: a72f9d4ea13d55d745ff1ed594747f10 + license: LGPL-2.1 and GPL-2.0 + size: 238119 + timestamp: 1660346964847 +- kind: conda + name: xz + version: 5.2.6 + build: h8d14728_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/xz-5.2.6-h8d14728_0.tar.bz2 + sha256: 54d9778f75a02723784dc63aff4126ff6e6749ba21d11a6d03c1f4775f269fe0 + md5: 515d77642eaa3639413c6b1bc3f94219 + depends: + - vc >=14.1,<15 + - vs2015_runtime >=14.16.27033 + license: LGPL-2.1 and GPL-2.0 + size: 217804 + timestamp: 1660346976440 +- kind: conda + name: zstd + version: 1.5.6 + build: h0ea2cb4_0 + subdir: win-64 + url: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.6-h0ea2cb4_0.conda + sha256: 768e30dc513568491818fb068ee867c57c514b553915536da09e5d10b4ebf3c3 + md5: 9a17230f95733c04dc40a2b1e5491d74 + depends: + - libzlib >=1.2.13,<2.0.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: BSD-3-Clause + license_family: BSD + size: 349143 + timestamp: 1714723445995 +- kind: conda + name: zstd + version: 1.5.6 + build: h915ae27_0 + subdir: osx-64 + url: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.6-h915ae27_0.conda + sha256: efa04a98cb149643fa54c4dad5a0179e36a5fbc88427ea0eec88ceed87fd0f96 + md5: 4cb2cd56f039b129bb0e491c1164167e + depends: + - __osx >=10.9 + - libzlib >=1.2.13,<2.0.0a0 + license: BSD-3-Clause + license_family: BSD + size: 498900 + timestamp: 1714723303098 +- kind: conda + name: zstd + version: 1.5.6 + build: ha6fb4c9_0 + subdir: linux-64 + url: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda + sha256: c558b9cc01d9c1444031bd1ce4b9cff86f9085765f17627a6cd85fc623c8a02b + md5: 4d056880988120e29d75bfff282e0f45 + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 + license: BSD-3-Clause + license_family: BSD + size: 554846 + timestamp: 1714722996770 +- kind: conda + name: zstd + version: 1.5.6 + build: hb46c0d2_0 + subdir: osx-arm64 + url: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.6-hb46c0d2_0.conda + sha256: 2d4fd1ff7ee79cd954ca8e81abf11d9d49954dd1fef80f27289e2402ae9c2e09 + md5: d96942c06c3e84bfcc5efb038724a7fd + depends: + - __osx >=11.0 + - libzlib >=1.2.13,<2.0.0a0 + license: BSD-3-Clause + license_family: BSD + size: 405089 + timestamp: 1714723101397 diff --git a/pixi.toml b/pixi.toml new file mode 100644 index 0000000..0c9a4d0 --- /dev/null +++ b/pixi.toml @@ -0,0 +1,59 @@ +[project] +name = "resolvo" +authors = ["Bas Zalmstra "] +channels = ["conda-forge"] +platforms = ["linux-64", "win-64", "osx-arm64", "osx-64"] + +[tasks] +format = {depends_on = ["format-rust", "format-cpp"] } +test = {depends_on = ["test-rust", "test-cpp"] } + +# ---- Build Rust using Cargo ---- +[feature.build-rust.dependencies] +rust = "~=1.75.0" + +[feature.test-rust.tasks.test-rust] +cmd = "cargo test" + +[feature.test-rust.tasks.format-rust] +cmd = "cargo fmt" + +[environments.test-rust] +features = ["build-rust", "test-rust"] +solve-group = "default" + +# ---- Build C++ using CMake ---- +[feature.build-cpp.dependencies] +cmake = ">=3.29.4,<3.30" +cxx-compiler = ">=1.7.0,<1.8" +ninja = ">=1.12.1,<1.13" + +[feature.build-cpp.tasks.configure] +cmd = "cmake -GNinja -S . -B build -DRESOLVO_BUILD_TESTING=ON" +inputs = ["CMakeLists.txt"] +outputs = ["build/CMakeFiles/"] + +[feature.build-cpp.tasks.build-cpp] +cmd = ["cmake", "--build", "build"] +depends-on = ["configure"] +inputs = ["CMakeLists.txt", "cpp/**/*", "src/**"] +outputs = ["build/bin/*"] + +[feature.build-cpp.tasks.test-cpp] +cmd = "ctest --test-dir build" +depends_on = ["build-cpp"] + +[environments.test-cpp] +features = ["build-cpp", "build-rust"] +solve-group = "default" + +# ---- Format C++ ---- +[feature.format-cpp.dependencies] +clang-format = ">=18.1.6,<18.2" + +[feature.format-cpp.tasks.format-cpp] +cmd = "clang-format -i cpp/include/*.h cpp/tests/*.cpp" + +[environments.format-cpp] +features=["format-cpp"] +solve-group="default" diff --git a/src/internal/id.rs b/src/internal/id.rs index ab84316..1ebc041 100644 --- a/src/internal/id.rs +++ b/src/internal/id.rs @@ -7,7 +7,7 @@ use crate::{internal::arena::ArenaId, Interner}; #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", serde(transparent))] -pub struct NameId(u32); +pub struct NameId(pub u32); impl ArenaId for NameId { fn from_usize(x: usize) -> Self { @@ -24,7 +24,7 @@ impl ArenaId for NameId { #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", serde(transparent))] -pub struct StringId(u32); +pub struct StringId(pub u32); impl ArenaId for StringId { fn from_usize(x: usize) -> Self { @@ -41,7 +41,7 @@ impl ArenaId for StringId { #[derive(Clone, Default, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", serde(transparent))] -pub struct VersionSetId(u32); +pub struct VersionSetId(pub u32); impl ArenaId for VersionSetId { fn from_usize(x: usize) -> Self { @@ -58,7 +58,7 @@ impl ArenaId for VersionSetId { #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", serde(transparent))] -pub struct SolvableId(u32); +pub struct SolvableId(pub u32); /// Internally used id for solvables that can also represent root and null. #[repr(transparent)]