From d23835c8749e2b88a78265e70e92cbd07c9c8c23 Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Tue, 28 Jul 2026 14:08:56 -0700 Subject: [PATCH 01/50] Refactor: tidy cdef declarations and struct init in .pyx files (#2434) Declare cdef locals at their point of initialization rather than at the top of the function, and replace field-by-field struct setup with Cython's struct-initializer syntax. Only complete initializers are converted. Cython does not zero-fill omitted members, so a partial initializer would leave them holding stack garbage; sites that depend on a preceding memset are left unchanged. Where every member is now supplied, the redundant memset is dropped. No behavior change. --- cuda_bindings/tests/cython/test_ccudart.pyx | 7 +- cuda_core/cuda/core/_device.pyx | 3 +- cuda_core/cuda/core/_device_resources.pyx | 3 +- cuda_core/cuda/core/_dlpack.pyx | 6 +- cuda_core/cuda/core/_graphics.pyx | 24 ++---- cuda_core/cuda/core/_linker.pyx | 3 +- cuda_core/cuda/core/_memory/_buffer.pyx | 3 +- .../core/_memory/_device_memory_resource.pyx | 8 +- .../cuda/core/_memory/_managed_memory_ops.pyx | 30 ++++---- cuda_core/cuda/core/_memory/_memory_pool.pyx | 5 +- .../cuda/core/_memory/_peer_access_utils.pyx | 12 +-- cuda_core/cuda/core/_stream.pyx | 3 +- cuda_core/cuda/core/_tensor_bridge.pyx | 6 +- cuda_core/cuda/core/_tensor_map.pyx | 3 +- cuda_core/cuda/core/graph/_graph_builder.pyx | 3 +- cuda_core/cuda/core/graph/_graph_node.pyx | 75 +++++++++---------- cuda_core/cuda/core/texture/_array.pyx | 16 ++-- .../cuda/core/texture/_mipmapped_array.pyx | 18 ++--- 18 files changed, 102 insertions(+), 126 deletions(-) diff --git a/cuda_bindings/tests/cython/test_ccudart.pyx b/cuda_bindings/tests/cython/test_ccudart.pyx index 4460ceb618a..3a59f952bd3 100644 --- a/cuda_bindings/tests/cython/test_ccudart.pyx +++ b/cuda_bindings/tests/cython/test_ccudart.pyx @@ -59,11 +59,8 @@ cdef extern from *: def test_ccudart_interoperable(): # struct - cdef dim3 oldDim, newDim - oldDim.x = 1 - oldDim.y = 2 - oldDim.z = 3 - newDim = copy_and_append_dim3(oldDim) + cdef dim3 oldDim = [1, 2, 3] + cdef dim3 newDim = copy_and_append_dim3(oldDim) assert oldDim.x + 1 == newDim.x assert oldDim.y + 1 == newDim.y assert oldDim.z + 1 == newDim.z diff --git a/cuda_core/cuda/core/_device.pyx b/cuda_core/cuda/core/_device.pyx index ea5bb62cc1b..3c04413db0b 100644 --- a/cuda_core/cuda/core/_device.pyx +++ b/cuda_core/cuda/core/_device.pyx @@ -1316,7 +1316,6 @@ class Device: cdef object res cdef SMResource sm_res cdef WorkqueueResource wq_res - cdef GreenCtxHandle h_green if options is None: raise ValueError( @@ -1348,7 +1347,7 @@ class Device: else: raise TypeError(f"Unsupported context resource type: {type(res)}") - h_green = create_green_ctx_handle( + cdef GreenCtxHandle h_green = create_green_ctx_handle( c_resources.data(), (c_resources.size()), (self._device_id), diff --git a/cuda_core/cuda/core/_device_resources.pyx b/cuda_core/cuda/core/_device_resources.pyx index 0c952821a04..15ca6c56685 100644 --- a/cuda_core/cuda/core/_device_resources.pyx +++ b/cuda_core/cuda/core/_device_resources.pyx @@ -250,7 +250,6 @@ cdef object _resolve_split_by_count_request(SMResourceOptions options): cdef list counts = _broadcast_field(options.count, n_groups) cdef object first = counts[0] cdef object value - cdef unsigned int min_count if options.coscheduled_sm_count is not None: raise RuntimeError( @@ -270,7 +269,7 @@ cdef object _resolve_split_by_count_request(SMResourceOptions options): "use CUDA 13.1 or newer for per-group counts" ) - min_count = _to_sm_count(first) + cdef unsigned int min_count = _to_sm_count(first) return n_groups, min_count diff --git a/cuda_core/cuda/core/_dlpack.pyx b/cuda_core/cuda/core/_dlpack.pyx index 0c251881d11..a41b3a73e85 100644 --- a/cuda_core/cuda/core/_dlpack.pyx +++ b/cuda_core/cuda/core/_dlpack.pyx @@ -115,10 +115,8 @@ cdef inline int setup_dl_tensor_device(DLTensor* dl_tensor, object buf) except - cdef inline int setup_dl_tensor_dtype(DLTensor* dl_tensor) except -1 nogil: - cdef DLDataType* dtype = &dl_tensor.dtype - dtype.code = kDLInt - dtype.lanes = 1 - dtype.bits = 8 + dl_tensor.dtype = DLDataType( + code=kDLInt, bits=8, lanes=1) return 0 diff --git a/cuda_core/cuda/core/_graphics.pyx b/cuda_core/cuda/core/_graphics.pyx index c5fc5c83ecc..764e2ec7688 100644 --- a/cuda_core/cuda/core/_graphics.pyx +++ b/cuda_core/cuda/core/_graphics.pyx @@ -209,10 +209,9 @@ cdef class GraphicsResource: return self def _get_mapped_buffer(self) -> object: - cdef Buffer buf if self._mapped_buffer is None: return None - buf = self._mapped_buffer + cdef Buffer buf = self._mapped_buffer if not buf._h_ptr: self._mapped_buffer = None return None @@ -250,20 +249,16 @@ cdef class GraphicsResource: CUDAError If the mapping fails. """ - cdef Stream s_obj - cdef cydriver.CUgraphicsResource raw - cdef cydriver.CUstream cy_stream cdef cydriver.CUdeviceptr dev_ptr = 0 cdef size_t size = 0 - cdef Buffer buf if not self._handle: raise RuntimeError("GraphicsResource has been closed") if self._get_mapped_buffer() is not None: raise RuntimeError("GraphicsResource is already mapped") - s_obj = Stream_accept(stream) - raw = as_cu(self._handle) - cy_stream = as_cu(s_obj._h_stream) + cdef Stream s_obj = Stream_accept(stream) + cdef cydriver.CUgraphicsResource raw = as_cu(self._handle) + cdef cydriver.CUstream cy_stream = as_cu(s_obj._h_stream) with nogil: HANDLE_RETURN( cydriver.cuGraphicsMapResources(1, &raw, cy_stream) @@ -271,7 +266,7 @@ cdef class GraphicsResource: HANDLE_RETURN( cydriver.cuGraphicsResourceGetMappedPointer(&dev_ptr, &size, raw) ) - buf = Buffer_from_deviceptr_handle( + cdef Buffer buf = Buffer_from_deviceptr_handle( deviceptr_create_mapped_graphics(dev_ptr, self._handle, s_obj._h_stream), size, None, @@ -299,14 +294,12 @@ cdef class GraphicsResource: CUDAError If the unmapping fails. """ - cdef object buf_obj - cdef Buffer buf if not self._handle: raise RuntimeError("GraphicsResource has been closed") - buf_obj = self._get_mapped_buffer() + cdef object buf_obj = self._get_mapped_buffer() if buf_obj is None: raise RuntimeError("GraphicsResource is not mapped") - buf = buf_obj + cdef Buffer buf = buf_obj buf.close(stream=stream) self._mapped_buffer = None @@ -332,11 +325,10 @@ cdef class GraphicsResource: Optional override for the stream used to close the currently mapped buffer, if one exists. """ - cdef object buf_obj cdef Buffer buf if not self._handle: return - buf_obj = self._get_mapped_buffer() + cdef object buf_obj = self._get_mapped_buffer() if buf_obj is not None: buf = buf_obj buf.close(stream=stream) diff --git a/cuda_core/cuda/core/_linker.pyx b/cuda_core/cuda/core/_linker.pyx index 753fa28b0d3..39b1f010a9e 100644 --- a/cuda_core/cuda/core/_linker.pyx +++ b/cuda_core/cuda/core/_linker.pyx @@ -544,11 +544,10 @@ cdef inline void Linker_add_code_object(Linker self, object object_code) except cdef cydriver.CUjitInputType c_drv_input_type cdef const char* c_data_ptr cdef size_t c_data_size - cdef const char* c_name_ptr cdef const char* c_file_ptr name_bytes = f"{object_code.name}".encode() - c_name_ptr = name_bytes + cdef const char* c_name_ptr = name_bytes input_types = _nvjitlink_input_types if self._use_nvjitlink else _driver_input_types py_input_type = input_types.get(object_code.code_type) diff --git a/cuda_core/cuda/core/_memory/_buffer.pyx b/cuda_core/cuda/core/_memory/_buffer.pyx index 97ef892547d..d5ecac6cc09 100644 --- a/cuda_core/cuda/core/_memory/_buffer.pyx +++ b/cuda_core/cuda/core/_memory/_buffer.pyx @@ -422,8 +422,7 @@ cdef class Buffer: if not isinstance(max_version, tuple) or len(max_version) != 2: raise BufferError(f"Expected max_version tuple[int, int], got {max_version}") versioned = max_version >= (1, 0) - capsule = make_py_capsule(self, versioned) - return capsule + return make_py_capsule(self, versioned) def __dlpack_device__(self) -> tuple[int, int]: return classify_dl_device(self) diff --git a/cuda_core/cuda/core/_memory/_device_memory_resource.pyx b/cuda_core/cuda/core/_memory/_device_memory_resource.pyx index 45d8d543ac4..22b1488f638 100644 --- a/cuda_core/cuda/core/_memory/_device_memory_resource.pyx +++ b/cuda_core/cuda/core/_memory/_device_memory_resource.pyx @@ -321,10 +321,10 @@ cpdef str DMR_mempool_get_access(DeviceMemoryResource dmr, int device_id): cdef int dev_id = Device(device_id).device_id cdef cydriver.CUmemAccess_flags flags - cdef cydriver.CUmemLocation location - - location.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE - location.id = dev_id + cdef cydriver.CUmemLocation location = cydriver.CUmemLocation( + type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, + id=dev_id, + ) with nogil: HANDLE_RETURN(cydriver.cuMemPoolGetAccess(&flags, as_cu(dmr._h_pool), &location)) diff --git a/cuda_core/cuda/core/_memory/_managed_memory_ops.pyx b/cuda_core/cuda/core/_memory/_managed_memory_ops.pyx index c07fb719dd9..b2ecde29f39 100644 --- a/cuda_core/cuda/core/_memory/_managed_memory_ops.pyx +++ b/cuda_core/cuda/core/_memory/_managed_memory_ops.pyx @@ -80,7 +80,6 @@ cdef tuple _coerce_batch_buffers(object buffers, str what): cdef tuple _broadcast_locations(object location, Py_ssize_t n, bint allow_none, str what): - cdef object coerced if isinstance(location, Sequence): if len(location) != n: raise ValueError( @@ -88,28 +87,30 @@ cdef tuple _broadcast_locations(object location, Py_ssize_t n, bint allow_none, f"targets length {n}" ) return tuple(_coerce_location(loc, allow_none=allow_none) for loc in location) - coerced = _coerce_location(location, allow_none=allow_none) + cdef object coerced = _coerce_location(location, allow_none=allow_none) return tuple([coerced] * n) IF CUDA_CORE_BUILD_MAJOR >= 13: # Convert a _LocSpec dataclass to a cydriver.CUmemLocation struct. cdef inline cydriver.CUmemLocation _to_cumemlocation(object loc): - cdef cydriver.CUmemLocation out cdef str kind = loc.kind if kind == "device": - out.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE - out.id = loc.id + return cydriver.CUmemLocation( + type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, + id=loc.id) elif kind == "host": - out.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST - out.id = 0 + return cydriver.CUmemLocation( + type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST, + id=0) elif kind == "host_numa": - out.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA - out.id = loc.id + return cydriver.CUmemLocation( + type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA, + id=loc.id) else: # host_numa_current - out.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT - out.id = 0 - return out + return cydriver.CUmemLocation( + type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT, + id=0) ELSE: # CUDA 12 cuMemPrefetchAsync takes a device ordinal (-1 = host). cdef inline int _to_legacy_device(object loc) except? -2: @@ -223,8 +224,9 @@ cdef void _do_single_advise(Buffer buf, object advice_value, object loc, bint al # Driver ignores location for read_mostly / unset_preferred_location # advice values but still validates the CUmemLocation; pass a # host placeholder. - cu_loc.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST - cu_loc.id = 0 + cu_loc = cydriver.CUmemLocation( + type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST, + id=0) else: cu_loc = _to_cumemlocation(loc) with nogil: diff --git a/cuda_core/cuda/core/_memory/_memory_pool.pyx b/cuda_core/cuda/core/_memory/_memory_pool.pyx index cf7c48068f1..2de31af42d7 100644 --- a/cuda_core/cuda/core/_memory/_memory_pool.pyx +++ b/cuda_core/cuda/core/_memory/_memory_pool.pyx @@ -275,10 +275,9 @@ cdef int MP_init_current_pool( Requires CUDA 13+. """ IF CUDA_CORE_BUILD_MAJOR >= 13: - cdef cydriver.CUmemLocation loc cdef cydriver.CUmemoryPool pool - loc.id = loc_id - loc.type = loc_type + cdef cydriver.CUmemLocation loc = cydriver.CUmemLocation( + type=loc_type, id=loc_id) with nogil: HANDLE_RETURN(cydriver.cuMemGetMemPool(&pool, &loc, alloc_type)) self._h_pool = create_mempool_handle_ref(pool) diff --git a/cuda_core/cuda/core/_memory/_peer_access_utils.pyx b/cuda_core/cuda/core/_memory/_peer_access_utils.pyx index 9a035378ecf..69d59f9e005 100644 --- a/cuda_core/cuda/core/_memory/_peer_access_utils.pyx +++ b/cuda_core/cuda/core/_memory/_peer_access_utils.pyx @@ -92,7 +92,7 @@ cdef inline tuple _query_peer_access_ids(DeviceMemoryResource mr): cdef cydriver.CUmemLocation location cdef cydriver.CUmemoryPool h_pool = as_cu(mr._h_pool) cdef vector[int] peers - cdef size_t i, n + cdef size_t i location.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE @@ -106,17 +106,17 @@ cdef inline tuple _query_peer_access_ids(DeviceMemoryResource mr): if flags == cydriver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE: peers.push_back(dev_id) - n = peers.size() + cdef size_t n = peers.size() return tuple(peers[i] for i in range(n)) cdef inline bint _peer_access_includes(DeviceMemoryResource mr, int dev_id): """Return True if peer access from ``dev_id`` is currently granted.""" cdef cydriver.CUmemAccess_flags flags - cdef cydriver.CUmemLocation location - - location.type = cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE - location.id = dev_id + cdef cydriver.CUmemLocation location = cydriver.CUmemLocation( + type=cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE, + id=dev_id, + ) with nogil: HANDLE_RETURN(cydriver.cuMemPoolGetAccess(&flags, as_cu(mr._h_pool), &location)) return flags == cydriver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE diff --git a/cuda_core/cuda/core/_stream.pyx b/cuda_core/cuda/core/_stream.pyx index 5212ec5c7de..21d6e27b5e6 100644 --- a/cuda_core/cuda/core/_stream.pyx +++ b/cuda_core/cuda/core/_stream.pyx @@ -125,7 +125,6 @@ cdef class Stream: cdef StreamHandle h_stream cdef cydriver.CUstream borrowed cdef ContextHandle h_context - cdef Stream self # Extract context handle if provided if ctx is not None: @@ -185,7 +184,7 @@ cdef class Stream: ) else: HANDLE_RETURN(res_code) - self = Stream._from_handle(cls, h_stream) + cdef Stream self = Stream._from_handle(cls, h_stream) self._nonblocking = int(nonblocking) self._priority = prio if device_id is not None: diff --git a/cuda_core/cuda/core/_tensor_bridge.pyx b/cuda_core/cuda/core/_tensor_bridge.pyx index dd41c77c051..c7a6743213c 100644 --- a/cuda_core/cuda/core/_tensor_bridge.pyx +++ b/cuda_core/cuda/core/_tensor_bridge.pyx @@ -361,9 +361,7 @@ def view_as_torch_tensor( cdef int32_t dtype_code cdef int32_t device_type, device_index cdef StridedMemoryView buf - cdef int itemsize cdef intptr_t _stream_ptr_int - cdef _StridedLayout layout # Note: we intentionally skip PyTorch's Python-level __dlpack__ guards # (requires_grad, is_conj, is_neg, non-strided layout, wrong-device) @@ -436,8 +434,8 @@ def view_as_torch_tensor( # Build _StridedLayout. init_from_ptr copies shape/strides so we are # safe even though they are borrowed pointers. - itemsize = _get_aoti_itemsize(dtype_code) - layout = _StridedLayout.__new__(_StridedLayout) + cdef int itemsize = _get_aoti_itemsize(dtype_code) + cdef _StridedLayout layout = _StridedLayout.__new__(_StridedLayout) layout.init_from_ptr( ndim, sizes_ptr, diff --git a/cuda_core/cuda/core/_tensor_map.pyx b/cuda_core/cuda/core/_tensor_map.pyx index 7e059fe7b98..b3cdb0b401a 100644 --- a/cuda_core/cuda/core/_tensor_map.pyx +++ b/cuda_core/cuda/core/_tensor_map.pyx @@ -485,7 +485,6 @@ cdef class TensorMapDescriptor: cdef int _check_context_compat(self) except -1: cdef cydriver.CUcontext current_ctx cdef cydriver.CUdevice current_dev - cdef int current_dev_id if self._context == 0 and self._device_id < 0: return 0 with nogil: @@ -497,7 +496,7 @@ cdef class TensorMapDescriptor: "TensorMapDescriptor was created in a different CUDA context") with nogil: HANDLE_RETURN(cydriver.cuCtxGetDevice(¤t_dev)) - current_dev_id = current_dev + cdef int current_dev_id = current_dev if self._device_id >= 0 and current_dev_id != self._device_id: raise RuntimeError( f"TensorMapDescriptor belongs to device {self._device_id}, " diff --git a/cuda_core/cuda/core/graph/_graph_builder.pyx b/cuda_core/cuda/core/graph/_graph_builder.pyx index 3f5b57060b6..7b7a8445104 100644 --- a/cuda_core/cuda/core/graph/_graph_builder.pyx +++ b/cuda_core/cuda/core/graph/_graph_builder.pyx @@ -162,7 +162,6 @@ class GraphCompleteOptions: def _instantiate_graph(h_graph, options: GraphCompleteOptions | None = None) -> Graph: - cdef cydriver.CUgraphExec c_exec params = driver.CUDA_GRAPH_INSTANTIATE_PARAMS() if options: flags = 0 @@ -201,7 +200,7 @@ def _instantiate_graph(h_graph, options: GraphCompleteOptions | None = None) -> elif params.result_out != driver.CUgraphInstantiateResult.CUDA_GRAPH_INSTANTIATE_SUCCESS: raise RuntimeError(f"Graph instantiation failed with unexpected error code: {params.result_out}") - c_exec = int(py_exec) + cdef cydriver.CUgraphExec c_exec = int(py_exec) return Graph._init(c_exec) diff --git a/cuda_core/cuda/core/graph/_graph_node.pyx b/cuda_core/cuda/core/graph/_graph_node.pyx index 9e1cab09e7b..bded8f5b61c 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyx +++ b/cuda_core/cuda/core/graph/_graph_node.pyx @@ -163,13 +163,11 @@ cdef class GraphNode: already-destroyed node (no-op). """ cdef cydriver.CUgraphNode node = as_cu(self._h_node) - cdef GraphHandle h_graph - cdef cydriver.CUresult cleanup_status cdef PreparedAttachment prepared if node == NULL: return - h_graph = graph_node_get_graph(self._h_node) + cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) # Allocate the cleanup transaction before asking CUDA to destroy the # node. A failed CUDA call leaves metadata and wrappers unchanged. HANDLE_RETURN(graph_prepare_attachment( @@ -178,7 +176,7 @@ cdef class GraphNode: HANDLE_RETURN(cydriver.cuGraphDestroyNode(node)) # Publish attachment removal before invalidating graph and node aliases. - cleanup_status = graph_commit_attachment(prepared, node) + cdef cydriver.CUresult cleanup_status = graph_commit_attachment(prepared, node) invalidate_child_graph_state(h_graph, node) _node_registry.pop(self._h_node.get(), None) invalidate_graph_node(self._h_node) @@ -360,8 +358,8 @@ cdef class GraphNode: cdef cydriver.CUdeviceptr c_dst cdef unsigned int val cdef unsigned int elem_size - cdef OpaqueHandle dst_attachment_owner - dst_attachment_owner = _resolve_memcpy_operand(dst, dst_owner, "dst", &c_dst) + cdef OpaqueHandle dst_attachment_owner = _resolve_memcpy_operand( + dst, dst_owner, "dst", &c_dst) val, elem_size = _parse_fill_value(value) return GN_memset( self, c_dst, dst_attachment_owner, @@ -423,9 +421,10 @@ cdef class GraphNode: """ cdef cydriver.CUdeviceptr c_dst cdef cydriver.CUdeviceptr c_src - cdef OpaqueHandle dst_attachment_owner, src_attachment_owner - dst_attachment_owner = _resolve_memcpy_operand(dst, dst_owner, "dst", &c_dst) - src_attachment_owner = _resolve_memcpy_operand(src, src_owner, "src", &c_src) + cdef OpaqueHandle dst_attachment_owner = _resolve_memcpy_operand( + dst, dst_owner, "dst", &c_dst) + cdef OpaqueHandle src_attachment_owner = _resolve_memcpy_operand( + src, src_owner, "src", &c_src) return GN_memcpy( self, c_dst, dst_attachment_owner, c_src, src_attachment_owner, size) @@ -713,35 +712,36 @@ cdef inline GraphNode GN_create_impl(GraphNodeHandle h_node): cdef inline KernelNode GN_launch(GraphNode self, LaunchConfig conf, Kernel ker, ParamHolder ker_args): - cdef cydriver.CUDA_KERNEL_NODE_PARAMS node_params cdef cydriver.CUgraphNode new_node = NULL cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) cdef cydriver.CUgraphNode pred_node = as_cu(self._h_node) cdef cydriver.CUgraphNode* deps = NULL cdef size_t num_deps = 0 - cdef OpaqueHandle kernel_owner, args_owner + cdef OpaqueHandle args_owner cdef PreparedAttachment prepared if pred_node != NULL: deps = &pred_node num_deps = 1 - node_params.kern = as_cu(ker._h_kernel) - node_params.func = NULL - node_params.gridDimX = conf.grid[0] - node_params.gridDimY = conf.grid[1] - node_params.gridDimZ = conf.grid[2] - node_params.blockDimX = conf.block[0] - node_params.blockDimY = conf.block[1] - node_params.blockDimZ = conf.block[2] - node_params.sharedMemBytes = conf.shmem_size - node_params.kernelParams = (ker_args.ptr) - node_params.extra = NULL - node_params.ctx = NULL + cdef cydriver.CUDA_KERNEL_NODE_PARAMS node_params = cydriver.CUDA_KERNEL_NODE_PARAMS( + kern=as_cu(ker._h_kernel), + func=NULL, + gridDimX=conf.grid[0], + gridDimY=conf.grid[1], + gridDimZ=conf.grid[2], + blockDimX=conf.block[0], + blockDimY=conf.block[1], + blockDimZ=conf.block[2], + sharedMemBytes=conf.shmem_size, + kernelParams=(ker_args.ptr), + extra=NULL, + ctx=NULL, + ) # Keep the kernel and argument objects alive because CUDA copies argument # values but does not retain the resources they reference. - kernel_owner = ker._h_kernel + cdef OpaqueHandle kernel_owner = ker._h_kernel kernel_args = ker_args.kernel_args if kernel_args is not None: args_owner = make_opaque_py(kernel_args) @@ -881,10 +881,11 @@ cdef inline FreeNode GN_free(GraphNode self, cydriver.CUdeviceptr c_dptr): cdef inline OpaqueHandle _buffer_attachment_owner(Buffer buf, str label): """Copy a Buffer's device-pointer handle into an attachment owner.""" - cdef OpaqueHandle attachment_owner if not buf._h_ptr: raise ValueError(f"{label} Buffer has no active allocation") - attachment_owner = buf._h_ptr + # The local is required: Cython permits the DevicePtrHandle -> OpaqueHandle + # conversion on assignment, but not directly in a return statement. + cdef OpaqueHandle attachment_owner = buf._h_ptr return attachment_owner @@ -928,7 +929,6 @@ cdef inline MemsetNode GN_memset( GraphNode self, cydriver.CUdeviceptr c_dst, OpaqueHandle dst_owner, unsigned int val, unsigned int elem_size, size_t width, size_t height, size_t pitch): - cdef cydriver.CUDA_MEMSET_NODE_PARAMS memset_params cdef cydriver.CUgraphNode new_node = NULL cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) cdef cydriver.CUgraphNode pred_node = as_cu(self._h_node) @@ -944,13 +944,14 @@ cdef inline MemsetNode GN_memset( with nogil: HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) - c_memset(&memset_params, 0, sizeof(memset_params)) - memset_params.dst = c_dst - memset_params.value = val - memset_params.elementSize = elem_size - memset_params.width = width - memset_params.height = height - memset_params.pitch = pitch + cdef cydriver.CUDA_MEMSET_NODE_PARAMS memset_params = cydriver.CUDA_MEMSET_NODE_PARAMS( + dst=c_dst, + pitch=pitch, + value=val, + elementSize=elem_size, + width=width, + height=height, + ) if dst_owner: HANDLE_RETURN(graph_prepare_attachment( @@ -1081,14 +1082,13 @@ cdef inline EventRecordNode GN_record_event(GraphNode self, Event ev): cdef cydriver.CUgraphNode pred_node = as_cu(self._h_node) cdef cydriver.CUgraphNode* deps = NULL cdef size_t num_deps = 0 - cdef OpaqueHandle owner cdef PreparedAttachment prepared if pred_node != NULL: deps = &pred_node num_deps = 1 - owner = ev._h_event + cdef OpaqueHandle owner = ev._h_event HANDLE_RETURN(graph_prepare_attachment( h_graph, owner, OpaqueHandle(), &prepared)) @@ -1108,14 +1108,13 @@ cdef inline EventWaitNode GN_wait_event(GraphNode self, Event ev): cdef cydriver.CUgraphNode pred_node = as_cu(self._h_node) cdef cydriver.CUgraphNode* deps = NULL cdef size_t num_deps = 0 - cdef OpaqueHandle owner cdef PreparedAttachment prepared if pred_node != NULL: deps = &pred_node num_deps = 1 - owner = ev._h_event + cdef OpaqueHandle owner = ev._h_event HANDLE_RETURN(graph_prepare_attachment( h_graph, owner, OpaqueHandle(), &prepared)) diff --git a/cuda_core/cuda/core/texture/_array.pyx b/cuda_core/cuda/core/texture/_array.pyx index 0a1cb671daf..684ba79460f 100644 --- a/cuda_core/cuda/core/texture/_array.pyx +++ b/cuda_core/cuda/core/texture/_array.pyx @@ -522,7 +522,6 @@ def _create_opaque_array(options): shape_t = opts.shape cdef cydriver.CUarray_format c_format = _ARRAYFORMAT_TO_CU[opts.format] - cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR desc3d cdef int rank = len(shape_t) cdef unsigned int flags = ( cydriver.CUDA_ARRAY3D_SURFACE_LDST if opts.is_surface_load_store else 0 @@ -530,13 +529,14 @@ def _create_opaque_array(options): # cuArray3DCreate handles 1D/2D/3D uniformly (Height/Depth 0 sentinels), # so a single descriptor + create_array_handle covers every shape. - memset(&desc3d, 0, sizeof(desc3d)) - desc3d.Width = shape_t[0] - desc3d.Height = (shape_t[1] if rank >= 2 else 0) - desc3d.Depth = (shape_t[2] if rank >= 3 else 0) - desc3d.Format = c_format - desc3d.NumChannels = opts.num_channels - desc3d.Flags = flags + cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR desc3d = cydriver.CUDA_ARRAY3D_DESCRIPTOR( + Width=shape_t[0], + Height=(shape_t[1] if rank >= 2 else 0), + Depth=(shape_t[2] if rank >= 3 else 0), + Format=c_format, + NumChannels=opts.num_channels, + Flags=flags, + ) cdef OpaqueArrayHandle h = create_array_handle(desc3d) if not h: diff --git a/cuda_core/cuda/core/texture/_mipmapped_array.pyx b/cuda_core/cuda/core/texture/_mipmapped_array.pyx index 3f151f7bb9f..e9ad0fa478b 100644 --- a/cuda_core/cuda/core/texture/_mipmapped_array.pyx +++ b/cuda_core/cuda/core/texture/_mipmapped_array.pyx @@ -4,8 +4,6 @@ from __future__ import annotations -from libc.string cimport memset - from cuda.bindings cimport cydriver from cuda.core.texture._array cimport _array_from_handle from cuda.core.texture._array import ( @@ -201,7 +199,6 @@ def _create_mipmapped_array(options): shape_t = opts.shape cdef cydriver.CUarray_format c_format = _ARRAYFORMAT_TO_CU[opts.format] - cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR desc3d cdef int rank = len(shape_t) cdef unsigned int flags = ( cydriver.CUDA_ARRAY3D_SURFACE_LDST if opts.is_surface_load_store else 0 @@ -210,13 +207,14 @@ def _create_mipmapped_array(options): # Mipmap creation uses the 3D descriptor regardless of rank; lower-rank # shapes use Height=0/Depth=0 sentinels, matching cuArray3DCreate. - memset(&desc3d, 0, sizeof(desc3d)) - desc3d.Width = shape_t[0] - desc3d.Height = (shape_t[1] if rank >= 2 else 0) - desc3d.Depth = (shape_t[2] if rank >= 3 else 0) - desc3d.Format = c_format - desc3d.NumChannels = opts.num_channels - desc3d.Flags = flags + cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR desc3d = cydriver.CUDA_ARRAY3D_DESCRIPTOR( + Width=shape_t[0], + Height=(shape_t[1] if rank >= 2 else 0), + Depth=(shape_t[2] if rank >= 3 else 0), + Format=c_format, + NumChannels=opts.num_channels, + Flags=flags, + ) cdef MipmappedArrayHandle h = create_mipmapped_array_handle(desc3d, c_levels) if not h: From ac0bb236942f9750f6b8138e0898c8f5deae102b Mon Sep 17 00:00:00 2001 From: Jinfeng Li Date: Tue, 28 Jul 2026 19:22:45 -0400 Subject: [PATCH 02/50] Add pre-commit check to keep pixi cuda-version pins in sync with ci/versions.yml (#2306) * Got initial version to address issue 2183. Let pre-commit check covers pixi cuda version pins to ci/versions.yml * rename to be more accurate * make error message more readable and accurate * put cuda_bindings / cuda_core to error message to be best accurate * add docstring * rename cuda_feature from cu13 to cu{major} to support bumping major version, e.g. 13.x.x to 14.x.x * add extracted line from pixi files to shown when check OK * add concrete build version alon side with expected version * polish to fix cosmetic * address pre commit check * Pin pyyaml in check-pixi-cuda-version pre-commit hook --- .pre-commit-config.yaml | 8 +++ ci/tools/check_pixi_cuda_version.py | 91 +++++++++++++++++++++++++++++ 2 files changed, 99 insertions(+) create mode 100644 ci/tools/check_pixi_cuda_version.py diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 029e69da916..6e0485eb450 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -50,6 +50,14 @@ repos: files: ^cuda_bindings/ types: [text] + - id: check-pixi-cuda-version + name: Check pixi cuda-version pins track ci/versions.yml + entry: python ./ci/tools/check_pixi_cuda_version.py + language: python + additional_dependencies: [pyyaml==6.0.3] + files: '^(ci/versions\.yml|cuda_bindings/pixi\.toml|cuda_core/pixi\.toml)$' + pass_filenames: false + - id: no-markdown-in-docs-source name: Prevent markdown files in docs/source directories entry: bash -c diff --git a/ci/tools/check_pixi_cuda_version.py b/ci/tools/check_pixi_cuda_version.py new file mode 100644 index 00000000000..1ca931b9b48 --- /dev/null +++ b/ci/tools/check_pixi_cuda_version.py @@ -0,0 +1,91 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Check pixi cuda-version pins track ci/versions.yml (cuda.build.version).""" + +from __future__ import annotations + +import sys +from pathlib import Path + +import tomllib +import yaml + +ROOT = Path(__file__).resolve().parents[2] +VERSIONS_FILE_PATH = ROOT / "ci" / "versions.yml" +PIXI_FILES = [ROOT / d / "pixi.toml" for d in ("cuda_bindings", "cuda_core")] + + +def main() -> int: + """Verify cuda_bindings/cuda_core pixi pins match ci/versions.yml.""" + if not VERSIONS_FILE_PATH.is_file(): + print(f"error: {VERSIONS_FILE_PATH} not found", file=sys.stderr) + return 2 + try: + build_version = yaml.safe_load(VERSIONS_FILE_PATH.read_text(encoding="utf-8"))["cuda"]["build"]["version"] + except (KeyError, TypeError): + print(f"error: cuda.build.version not found in {VERSIONS_FILE_PATH}", file=sys.stderr) + return 2 + + major, minor, *_ = build_version.split(".") + expected = f"{major}.{minor}.*" + cuda_feature = f"cu{major}" + + errors: list[str] = [] + checked: list[str] = [] + for path in PIXI_FILES: + if not path.is_file(): + print(f"error: {path} not found", file=sys.stderr) + return 2 + with path.open("rb") as f: + data = tomllib.load(f) + rel = path.relative_to(ROOT) + try: + variants = data["workspace"]["build-variants"]["cuda-version"] + cuda_pin = data["feature"][cuda_feature]["dependencies"]["cuda-version"] + except KeyError as exc: + print( + f"error: {rel} missing feature {cuda_feature!r} or cuda-version key: {exc}", + file=sys.stderr, + ) + return 2 + if expected not in variants: + errors.append( + f"{rel}: workspace.build-variants.cuda-version={variants!r} " + f"does not include {expected!r} " + f"(from ci/versions.yml cuda.build.version={build_version!r})" + ) + if cuda_pin != expected: + errors.append( + f"{rel}: feature.{cuda_feature}.dependencies.cuda-version={cuda_pin!r} " + f"!= {expected!r} " + f"(from ci/versions.yml cuda.build.version={build_version!r})" + ) + + checked.append( + f"{rel} (workspace.build-variants.cuda-version={variants!r}, " + f"feature.{cuda_feature}.dependencies.cuda-version={cuda_pin!r})" + ) + + if errors: + print( + f"error: cuda_bindings/cuda_core pixi cuda-version pins out of sync with " + f"ci/versions.yml cuda.build.version={build_version!r} " + f"(expected pin {expected!r}):", + file=sys.stderr, + ) + for err in errors: + print(f" - {err}", file=sys.stderr) + return 1 + + print( + f"OK: pixi cuda-version pins match ci/versions.yml " + f"cuda.build.version={build_version!r} (expected pin {expected!r}):" + ) + for item in checked: + print(f" - {item}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) From 55a2c8800acc47143eb7ada86d6016221e7e595d Mon Sep 17 00:00:00 2001 From: Rui Luo Date: Tue, 28 Jul 2026 19:46:40 -0700 Subject: [PATCH 03/50] coverage: add cuda.core tests for system device, checkpoint, memory, stream, green context, and tensor map (#2404) Signed-off-by: Rui Luo --- .../tests/graph/test_graph_definition.py | 16 ++ cuda_core/tests/system/test_system_device.py | 33 +++++ cuda_core/tests/test_checkpoint.py | 139 ++++++++++++++++++ cuda_core/tests/test_green_context.py | 45 ++++++ cuda_core/tests/test_launcher.py | 53 +++++-- cuda_core/tests/test_memory.py | 70 +++++++++ cuda_core/tests/test_stream.py | 102 +++++++++++++ cuda_core/tests/test_tensor_map.py | 66 +++++++++ 8 files changed, 511 insertions(+), 13 deletions(-) diff --git a/cuda_core/tests/graph/test_graph_definition.py b/cuda_core/tests/graph/test_graph_definition.py index 50d4b4ac253..1d63504c7c4 100644 --- a/cuda_core/tests/graph/test_graph_definition.py +++ b/cuda_core/tests/graph/test_graph_definition.py @@ -701,6 +701,22 @@ def test_node_attrs_preserved_by_nodes(node_spec): assert getattr(retrieved, attr) == getattr(node, attr), f"{spec.name}.{attr} not preserved by nodes()" +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_host_callback_node_reconstructed_from_embedded_child(init_cuda): + """A host-callback node read through an embedded child graph is reconstructed via _create_from_driver.""" + # The same-wrapper nodes() (test_node_attrs_preserved_by_nodes) returns the + # registry-cached object and never exercises reconstruction; only the embedded + # child graph carries fresh, unregistered node handles. Host callback is + # mempool-free so it reconstructs here; alloc-based nodes stay cached. + child = GraphDefinition() + _build_host_callback_node(child) + parent = GraphDefinition() + reconstructed = list(parent.embed(child).child_graph.nodes()) + assert any(isinstance(n, HostCallbackNode) for n in reconstructed), ( + f"no reconstructed HostCallbackNode in {[type(n).__name__ for n in reconstructed]}" + ) + + def test_identity_preservation(init_cuda): """Round-trips through nodes(), edges(), and pred/succ return extant objects rather than duplicates.""" diff --git a/cuda_core/tests/system/test_system_device.py b/cuda_core/tests/system/test_system_device.py index b5fe8cccbfa..b8fe3505674 100644 --- a/cuda_core/tests/system/test_system_device.py +++ b/cuda_core/tests/system/test_system_device.py @@ -722,6 +722,39 @@ def test_temperature(): assert sensor.default_min_temp <= sensor.current_temp <= sensor.default_max_temp +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_temperature_arg_validation(): + # Both getters reject an unknown key before issuing any NVML call. + temperature = system.Device(index=0).temperature + with pytest.raises(ValueError, match="Invalid temperature threshold type"): + temperature.get_threshold("not-a-threshold") + with pytest.raises(ValueError, match="Invalid thermal sensor index"): + temperature.get_thermal_settings("not-a-sensor") + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_device_constructor_selector_validation(): + # The constructor requires exactly one selector, rejected before NVML is touched. + with pytest.raises(ValueError, match="only one of"): + system.Device(index=0, uuid="ignored") + with pytest.raises(ValueError, match="either a device"): + system.Device() + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_device_arg_validation(): + device = system.Device(index=0) + # Each argument validator raises before reaching the driver/NVML call. + with pytest.raises(ValueError, match="Invalid affinity scope"): + device.get_memory_affinity("not-a-scope") + with pytest.raises(ValueError, match="Invalid affinity scope"): + device.get_cpu_affinity("not-a-scope") + with pytest.raises(ValueError, match="Invalid topology level"): + list(device.get_topology_nearest_gpus("not-a-level")) + with pytest.raises(ValueError, match="Invalid P2P caps index"): + system.get_p2p_status(device, device, "not-an-index") + + def test_pstates(): for device in system.Device.get_all_devices(): with unsupported_before(device, None): diff --git a/cuda_core/tests/test_checkpoint.py b/cuda_core/tests/test_checkpoint.py index 5e70a162320..ff727eb9fff 100644 --- a/cuda_core/tests/test_checkpoint.py +++ b/cuda_core/tests/test_checkpoint.py @@ -409,6 +409,145 @@ def test_pid_is_read_only(self): proc.pid = 2 +# -- Pure helpers (no GPU / driver needed) --------------------------------- + +import ctypes + +from cuda.bindings import driver as _bindings_driver + +# The checkpoint functions, structs, and enums are generated and shipped +# together from the same CUDA headers, so probe them as one atomic API surface. +_HAS_CHECKPOINT_BINDINGS = all(hasattr(_bindings_driver, name) for name in checkpoint._REQUIRED_BINDING_ATTRS) + +needs_checkpoint_bindings = pytest.mark.skipif( + not _HAS_CHECKPOINT_BINDINGS, + reason="cuda.bindings does not expose the CUDA checkpoint API", +) + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +class TestCheckpointHelpers: + """Host-only tests for the arg-validation and struct-marshalling helpers. + + The driver-backed lifecycle/migration scenarios skip without a checkpoint-capable + Linux driver, so these are the only coverage of these helpers on most CI. + """ + + @pytest.mark.parametrize( + ("value", "error_type", "match"), + [ + (True, TypeError, "timeout_ms must be an int"), + (1.5, TypeError, "timeout_ms must be an int"), + ("0", TypeError, "timeout_ms must be an int"), + (-1, ValueError, "timeout_ms must be >= 0"), + ], + ) + def test_check_timeout_ms_rejects_invalid(self, value, error_type, match): + with pytest.raises(error_type, match=match): + checkpoint._check_timeout_ms(value) + + def test_make_restore_args_rejects_non_mapping(self): + with pytest.raises(TypeError, match="gpu_mapping must be a mapping"): + checkpoint._make_restore_args(_bindings_driver, [("a", "b")]) + + def test_make_restore_args_empty_mapping_returns_none(self): + # An empty mapping produces no GPU pairs, so there is nothing to restore. + assert checkpoint._make_restore_args(_bindings_driver, {}) is None + + @needs_checkpoint_bindings + def test_make_restore_args_builds_pairs(self): + old = "00000000-0000-0000-0000-000000000001" + new = "00000000-0000-0000-0000-000000000002" + args = checkpoint._make_restore_args(_bindings_driver, {old: new}) + assert isinstance(args, _bindings_driver.CUcheckpointRestoreArgs) + assert args.gpuPairsCount == 1 + # The pair must map old->new in that order (not swapped or duplicated). + pair = args.gpuPairs[0] + assert bytes(pair.oldUuid.bytes) == bytes.fromhex(old.replace("-", "")) + assert bytes(pair.newUuid.bytes) == bytes.fromhex(new.replace("-", "")) + + @pytest.mark.parametrize( + ("value", "match"), + [ + ("not-hex-zz", "32 hex characters"), + ("00", "32 hex characters"), # valid hex but wrong length (1 byte) + ], + ) + def test_as_cuuuid_rejects_bad_strings(self, value, match): + with pytest.raises(ValueError, match=match): + checkpoint._as_cuuuid(_bindings_driver, value, []) + + def test_as_cuuuid_rejects_wrong_type(self): + with pytest.raises(TypeError, match="must be CUDA UUID objects or UUID strings"): + checkpoint._as_cuuuid(_bindings_driver, 12345, []) + + @pytest.mark.parametrize( + "value", + [ + "0123456789abcdef0123456789abcdef", # bare 32 hex chars + "01234567-89ab-cdef-0123-456789abcdef", # hyphenated form (Device.uuid style) + ], + ) + def test_as_cuuuid_from_string_decodes_bytes_and_appends_backing_buffer(self, value): + buffers = [] + result = checkpoint._as_cuuuid(_bindings_driver, value, buffers) + assert isinstance(result, _bindings_driver.CUuuid) + # Stripped hex must decode to the exact 16 CUuuid bytes (guards fromhex/replace). + assert bytes(result.bytes) == bytes.fromhex(value.replace("-", "")) + # _as_cuuuid appends the backing ctypes buffer to the caller's list so it survives + # until the caller copies the bytes into the pair struct. + assert len(buffers) == 1 + assert isinstance(buffers[0], ctypes.Array) + + def test_as_cuuuid_passes_through_cuuuid_instance(self): + existing = _bindings_driver.CUuuid() + # An already-constructed CUuuid is returned unchanged and adds no buffer. + buffers = [] + assert checkpoint._as_cuuuid(_bindings_driver, existing, buffers) is existing + assert buffers == [] + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +class TestCheckpointDriverDispatch: + """Driver-dispatch (_call_driver) result-code / exception translation. + + _call_driver runs against a boundary-mock ``func`` (dependency-injected as its + argument) so the translation branches exercise without a live driver — the real + ``checkpoint._driver`` still supplies the CUresult enum. + """ + + @pytest.mark.parametrize("err_name", ["CUDA_ERROR_NOT_FOUND", "CUDA_ERROR_NOT_SUPPORTED"]) + def test_call_driver_translates_unsupported_result_codes(self, err_name): + """NOT_FOUND / NOT_SUPPORTED become the 'not supported by the installed NVIDIA driver' RuntimeError.""" + driver = checkpoint._driver + + def fake(*args): + return (getattr(driver.CUresult, err_name),) + + with pytest.raises(RuntimeError, match="not supported by the installed NVIDIA driver"): + checkpoint._call_driver(driver, fake) + + def test_call_driver_translates_missing_symbol_runtimeerror(self): + """A binding 'symbol not found' RuntimeError is rewritten into the upgrade-your-driver message.""" + driver = checkpoint._driver + + def fake(*args): + raise RuntimeError("Function cuCheckpointProcessLock not found") + + with pytest.raises(RuntimeError, match="not supported by the installed NVIDIA driver"): + checkpoint._call_driver(driver, fake) + + def test_call_driver_reraises_unrelated_runtimeerror(self): + """A RuntimeError unrelated to the missing-symbol case propagates as-is.""" + driver = checkpoint._driver + + def fake(*args): + raise RuntimeError("some other failure") + + with pytest.raises(RuntimeError, match="some other failure"): + checkpoint._call_driver(driver, fake) + + # -- Lifecycle (single GPU, real driver) ----------------------------------- diff --git a/cuda_core/tests/test_green_context.py b/cuda_core/tests/test_green_context.py index 693dffacdc7..a42178031cc 100644 --- a/cuda_core/tests/test_green_context.py +++ b/cuda_core/tests/test_green_context.py @@ -183,6 +183,24 @@ def test_create_context_requires_resources(init_cuda): init_cuda.create_context(object()) +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_context_handle_alias_and_closed_queries(init_cuda, sm_resource): + """``Context._handle`` mirrors ``.handle``; after a (non-current) green + context is closed its handle-backed queries degrade gracefully: ``handle`` is + ``None``, ``is_green`` is ``False``, and ``resources`` raises.""" + groups, _ = sm_resource.split(SMResourceOptions(count=None)) + ctx = init_cuda.create_context(ContextOptions(resources=[groups[0]])) + # `_handle` is a thin alias of the public `handle` property. + assert ctx._handle == ctx.handle + assert ctx.handle is not None + + ctx.close() + assert ctx.handle is None + assert ctx.is_green is False + with pytest.raises(RuntimeError, match="Cannot query resources"): + _ = ctx.resources + + # --------------------------------------------------------------------------- # SM resource query # --------------------------------------------------------------------------- @@ -308,6 +326,20 @@ def test_negative_count_raises(self, sm_resource): with pytest.raises(ValueError, match="count must be non-negative"): sm_resource.split(SMResourceOptions(count=-1)) + @pytest.mark.agent_authored(model="claude-opus-4.8") + def test_empty_count_sequence_raises(self, sm_resource): + """An empty ``count`` sequence has no groups to split into.""" + with pytest.raises(ValueError, match="count sequence must not be empty"): + sm_resource.split(SMResourceOptions(count=[])) + + @pytest.mark.agent_authored(model="claude-opus-4.8") + @pytest.mark.parametrize("bad_count", [3.5, object()]) + def test_count_wrong_type_raises(self, sm_resource, bad_count): + """``count`` that is neither int, Sequence, nor None is rejected before + any driver call.""" + with pytest.raises(TypeError, match="count must be int, Sequence, or None"): + sm_resource.split(SMResourceOptions(count=bad_count)) + def test_dry_run_cannot_create_context(self, init_cuda, sm_resource): groups, _ = sm_resource.split(SMResourceOptions(count=None), dry_run=True) assert len(groups) == 1 @@ -498,6 +530,19 @@ def test_stream_resources_match_context(self, green_ctx, sm_resource): except (RuntimeError, ValueError, CUDAError): pass # workqueue not available on this driver/build + @pytest.mark.agent_authored(model="claude-opus-4.8") + def test_primary_context_stream_sm_resources(self, init_cuda, sm_resource): + """A stream on the *primary* (non-green) context queries SM resources via + the plain ``cuCtxGetDevResource`` path (distinct from the green-context + path exercised elsewhere): the stream carries a context handle but it is + not a green context, so the whole device is reported.""" + stream = init_cuda.create_stream() + try: + stream_sm = stream.resources.sm + assert stream_sm.sm_count == sm_resource.sm_count + finally: + stream.close() + # --------------------------------------------------------------------------- # Kernel launch in green context (explicit model) diff --git a/cuda_core/tests/test_launcher.py b/cuda_core/tests/test_launcher.py index 942952d29b8..08f2c9e041d 100644 --- a/cuda_core/tests/test_launcher.py +++ b/cuda_core/tests/test_launcher.py @@ -536,25 +536,52 @@ class MyBool(ctypes.c_bool): assert holder.ptr != 0 +@pytest.mark.agent_authored(model="claude-opus-4.8") @requires_module(np, "2.2.5", reason="need numpy 2.2.5+ (numpy GH #28632)") @pytest.mark.parametrize( - ("scalar_kind", "np_dtype", "cpp_type", "raw_value"), + ("base_type", "np_dtype", "cpp_type", "raw_value"), [ - ("ctypes", np.int32, "signed int", -123456), - ("numpy", np.float32, "float", 3.14), + # ctypes scalar subclasses — one per prepare_ctypes_arg isinstance-fallback + # branch. Values are chosen to expose a wrong width/sign: unsigned values + # exceed the same-width signed max, and c_uint64 exceeds uint32 max so a + # uint64 branch misrouted to prepare_arg[uint32_t] truncates 0x1_0000_0001 + # to 1 and fails the readback. + (ctypes.c_bool, np.bool_, "bool", True), + (ctypes.c_int8, np.int8, "signed char", -42), + (ctypes.c_int16, np.int16, "signed short", -1234), + (ctypes.c_int32, np.int32, "signed int", -123456), + (ctypes.c_int64, np.int64, "signed long long", -123456789), + (ctypes.c_uint8, np.uint8, "unsigned char", 200), + (ctypes.c_uint16, np.uint16, "unsigned short", 60000), + (ctypes.c_uint32, np.uint32, "unsigned int", 4000000000), + (ctypes.c_uint64, np.uint64, "unsigned long long", 0x1_0000_0001), + (ctypes.c_float, np.float32, "float", 3.14), + (ctypes.c_double, np.float64, "double", 2.718281828), + # numpy scalar subclass — prepare_numpy_arg fallback + (np.float32, np.float32, "float", 3.14), + ], + ids=[ + "ctypes_bool", + "ctypes_int8", + "ctypes_int16", + "ctypes_int32", + "ctypes_int64", + "ctypes_uint8", + "ctypes_uint16", + "ctypes_uint32", + "ctypes_uint64", + "ctypes_float", + "ctypes_double", + "numpy_float32", ], - ids=["ctypes_subclass", "numpy_subclass"], ) -def test_launch_scalar_argument_subclass_fallback(scalar_kind, np_dtype, cpp_type, raw_value): - """Subclassed scalar arguments survive fallback handling and reach the kernel.""" - if scalar_kind == "ctypes": - - class Subclassed(ctypes.c_int32): - pass - else: +def test_launch_scalar_argument_subclass_fallback(base_type, np_dtype, cpp_type, raw_value): + """Subclassed scalar arguments survive fallback handling and reach the kernel + with the correct width/sign. The readback value (not just ptr != 0) guards each + fallback branch against marshalling the wrong C type, e.g. uint64 -> uint32_t.""" - class Subclassed(np.float32): - pass + class Subclassed(base_type): + pass scalar = Subclassed(raw_value) expected = np_dtype(raw_value) diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index 5ef48919a50..c02a88e4a28 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -1899,3 +1899,73 @@ def test_dmr_peer_accessible_by_setter_empty(mempool_device): assert set(mr.peer_accessible_by) == set() mr.peer_accessible_by = [] assert set(mr.peer_accessible_by) == set() + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_mempool_attributes_cannot_instantiate_directly(): + """_MemPoolAttributes cannot be instantiated directly.""" + from cuda.core._memory._memory_pool import _MemPoolAttributes + + with pytest.raises(RuntimeError, match="cannot be instantiated directly"): + _MemPoolAttributes() + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_dmr_handle_and_ownership(mempool_device): + """An options-created pool is handle-owning with a live handle; wrapping the device's current pool is non-owning.""" + owned = DeviceMemoryResource(mempool_device, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) + assert owned.is_handle_owned is True + handle = owned.handle + assert handle is not None + assert int(handle) != 0 + + non_owned = DeviceMemoryResource(mempool_device) + assert non_owned.is_handle_owned is False + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_dmr_deallocate_frees_pool_pointer(mempool_device): + """Closing a Buffer.from_handle(..., mr=mr) view frees the pointer via the Python + _MemPool.deallocate path; the pool's in-use bytes drop back.""" + dev = mempool_device + stream = dev.default_stream + mr = DeviceMemoryResource(dev, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) + size = 256 + # Raw pool allocation owned by nobody else, so exactly one owner frees it (no + # double free); a Buffer.from_handle view then routes teardown through the + # Python deallocate path that mr.allocate()'s C++-direct free would skip. + ptr = handle_return(driver.cuMemAllocFromPoolAsync(size, mr.handle, stream.handle)) + stream.sync() + used_after_alloc = mr.attributes.used_mem_current + assert used_after_alloc >= size + buf = Buffer.from_handle(int(ptr), size, mr=mr) + buf.close(stream) + stream.sync() + assert int(buf.handle) == 0 + # In-use bytes fell back, so the pointer was actually returned (buf.handle == 0 + # alone wouldn't prove it: the deleter callback swallows a failed free). + assert mr.attributes.used_mem_current < used_after_alloc + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_dmr_close_is_idempotent(mempool_device): + """Closing an owned DeviceMemoryResource twice is safe (the second close is a no-op).""" + mr = DeviceMemoryResource(mempool_device, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) + assert mr.is_handle_owned is True + assert int(mr.handle) != 0 + mr.close() + # First close releases the pool handle itself, not just ownership. + assert int(mr.handle) == 0 + assert mr.is_handle_owned is False + mr.close() # no-op on the now-null handle + assert int(mr.handle) == 0 + assert mr.is_handle_owned is False + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_dmr_ipc_enabled_unsupported_raises(mempool_device): + """Requesting an IPC-enabled pool where memory IPC is unsupported raises RuntimeError.""" + if not IS_WINDOWS: + pytest.skip("memory IPC is supported on this platform; unsupported-raise path is Windows-only") + with pytest.raises(RuntimeError, match="IPC is not available"): + DeviceMemoryResource(mempool_device, DeviceMemoryResourceOptions(ipc_enabled=True)) diff --git a/cuda_core/tests/test_stream.py b/cuda_core/tests/test_stream.py index 49e372c9d53..39717861c51 100644 --- a/cuda_core/tests/test_stream.py +++ b/cuda_core/tests/test_stream.py @@ -303,3 +303,105 @@ def test_default_stream_consistency(init_cuda): # Should be same object (or at least equal) assert default1 == default2 assert hash(default1) == hash(default2) + + +class _BadStreamProtocol: + """Object whose __cuda_stream__ (a method) returns a malformed value.""" + + def __init__(self, value): + self._value = value + + def __cuda_stream__(self): + return self._value + + +class _AttrStreamProtocol: + """Object implementing __cuda_stream__ as an attribute (deprecated form) + rather than a method; the tuple length is wrong so resolution stops before + any GPU work.""" + + __cuda_stream__ = (0, 1, 2) + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_stream_init_rejects_obj_and_options(): + """Stream._init rejects supplying both a foreign object and options.""" + from cuda.core._stream import Stream + + with pytest.raises(ValueError, match="obj and options cannot be both specified"): + Stream._init(obj=_BadStreamProtocol((0, 0)), options=StreamOptions()) + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +@pytest.mark.parametrize( + "value,match", + [ + ((0, 1, 2), "must return a sequence with 2 elements"), # wrong length + (5, "must return a sequence with 2 elements"), # not a sequence + ((1, 123), r"first element of the sequence.*must be 0"), # bad version + ], +) +def test_stream_init_rejects_bad_cuda_stream_protocol(value, match): + """A foreign object whose __cuda_stream__ returns a malformed value is + rejected before any handle is created.""" + from cuda.core._stream import Stream + + with pytest.raises(RuntimeError, match=match): + Stream._init(obj=_BadStreamProtocol(value)) + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_stream_init_warns_on_attribute_cuda_stream_protocol(): + """Implementing __cuda_stream__ as an attribute (not a method) is deprecated: + resolution emits a DeprecationWarning and then still rejects the malformed + (wrong-length) value with a RuntimeError.""" + from cuda.core._stream import Stream + + with ( + pytest.warns(DeprecationWarning, match="must be implemented as a method"), + pytest.raises(RuntimeError, match="must return a sequence with 2 elements"), + ): + Stream._init(obj=_AttrStreamProtocol()) + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_stream_init_from_existing_stream_object(init_cuda): + """Passing an existing Stream as the foreign object yields a borrowed stream over the same handle.""" + from cuda.core._stream import Stream + + src = Device().create_stream(options=StreamOptions()) + borrowed = Stream._init(obj=src) + assert int(borrowed.handle) == int(src.handle) + borrowed.close() + src.close() + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +def test_stream_from_handle_lazy_flag_and_priority_queries(init_cuda): + """A from_handle stream reports is_nonblocking and priority read back from the + driver (matching the source stream), not the constructor defaults.""" + from cuda.core._stream import Stream + + # priority=-1 (not the default 0) so the value proves the driver was actually queried. + real = Device().create_stream(options=StreamOptions(nonblocking=True, priority=-1)) + wrapped = Stream.from_handle(int(real.handle)) + assert wrapped.is_nonblocking is True + assert wrapped.priority == -1 + wrapped.close() + real.close() + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +@pytest.mark.thread_unsafe( + reason="mutates the process-global CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM env var that default_stream() reads live" +) +def test_default_stream_per_thread_when_env_set(monkeypatch): + """default_stream() returns the per-thread default stream when + CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM is set to a nonzero value, and the + legacy default stream otherwise.""" + from cuda.core._stream import default_stream + + monkeypatch.setenv("CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM", "1") + assert default_stream() is PER_THREAD_DEFAULT_STREAM + monkeypatch.delenv("CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM", raising=False) + assert default_stream() is LEGACY_DEFAULT_STREAM diff --git a/cuda_core/tests/test_tensor_map.py b/cuda_core/tests/test_tensor_map.py index 7abbaadb483..8670e910075 100644 --- a/cuda_core/tests/test_tensor_map.py +++ b/cuda_core/tests/test_tensor_map.py @@ -20,7 +20,9 @@ TensorMapL2Promotion, TensorMapOOBFill, TensorMapSwizzle, + _coerce_tensor_map_descriptor_options, _require_view_device, + _resolve_data_type, ) from cuda.core.utils import StridedMemoryView @@ -649,3 +651,67 @@ def test_from_im2col_wide_rank_validation(self, dev, skip_if_no_im2col_wide): pixels_per_column=4, data_type=TensorMapDataType.FLOAT32, ) + + +class _DtypeView: + """Minimal stand-in for a StridedMemoryView exposing only ``.dtype``. + + ``_resolve_data_type`` reads nothing else off the view, so this keeps the + host-only tests free of any GPU allocation. + """ + + def __init__(self, dtype): + self.dtype = dtype + + +@pytest.mark.agent_authored(model="claude-opus-4.8") +class TestTensorMapHelpers: + """Host-only coverage for the arg-marshalling helpers' input-validation branches. + + The happy-path normalize/coerce/resolve/stride cases are covered by the TMA + factory-method tests above once they run on TMA-capable hardware (e.g. the H200 + coverage runner). Only the rejection branches those tests never hit — real + devices never feed bad inputs — are pinned here. + """ + + # Rejected by the public TensorMapDescriptorOptions(...) constructor, whose + # __post_init__ runs the normalize/require-enum helpers. + @pytest.mark.parametrize( + ("kwargs", "match"), + [ + (dict(box_dim=5), "box_dim must be a tuple of ints"), + (dict(box_dim=(1, "x", 3)), r"box_dim\[1\] must be an int"), + (dict(box_dim=(32,), swizzle=2), "swizzle must be a TensorMapSwizzle"), + (dict(box_dim=(32,), interleave=0), "interleave must be a TensorMapInterleave"), + ], + ids=["box_dim_non_iterable", "box_dim_non_int_element", "swizzle_wrong_type", "interleave_wrong_type"], + ) + def test_options_rejects_invalid(self, kwargs, match): + with pytest.raises(TypeError, match=match): + TensorMapDescriptorOptions(**kwargs) + + @pytest.mark.parametrize( + ("view_dtype", "data_type", "match"), + [ + (None, np.complex128, "Unsupported dtype"), # explicit unsupported dtype + (None, None, "Cannot infer TMA data type"), # nothing to infer from + (np.dtype(np.complex64), None, "Unsupported dtype"), # view's dtype unsupported + ], + ids=["explicit_unsupported", "cannot_infer", "view_dtype_unsupported"], + ) + def test_resolve_data_type_rejects(self, view_dtype, data_type, match): + with pytest.raises(ValueError, match=match): + _resolve_data_type(_DtypeView(view_dtype), data_type) + + def test_coerce_requires_box_dim_without_options(self): + with pytest.raises(TypeError, match="box_dim is required unless options is provided"): + _coerce_tensor_map_descriptor_options( + None, + None, + element_strides=None, + data_type=None, + interleave=TensorMapInterleave.NONE, + swizzle=TensorMapSwizzle.NONE, + l2_promotion=TensorMapL2Promotion.NONE, + oob_fill=TensorMapOOBFill.NONE, + ) From 69c8e68fdd6d94ed009085baa1cde4d6227ac274 Mon Sep 17 00:00:00 2001 From: Aryan Putta Date: Wed, 29 Jul 2026 07:59:52 -0400 Subject: [PATCH 04/50] test(core): add cuda.core.__all__ vs public docs consistency check (#2347) * test(core): add cuda.core.__all__ vs public docs consistency check Closes #2326. Parses docs/source/api.rst (autosummary entries and data directives while cuda.core is the active module) and compares the flat public names against cuda.core.__all__ in both directions. Dotted entries such as graph.Graph or checkpoint.Process are submodule namespaces and are excluded. Symbols documented in api_private.rst are accepted as documented so returned-helper docs do not fail the check. The tests skip when cuda.core.__all__ is not defined, so this lands independently of #2300 and activates once #2300 merges. Also adds the __all__-names-resolve guard suggested in the #2300 review. Signed-off-by: Aryan * test(core): land cuda.core.__all__ and extend docs check to public subpackages Addresses review feedback that the consistency check was too narrow: - Define cuda.core.__all__ (flat public namespace) so the check runs instead of skipping, and add an aggregated __all__ to cuda.core.graph derived from its star-imported submodules. - Auto-discover public subpackages from cuda.core.__path__ (graph, system, texture, utils, and any added later; the internal cuNN wheel shims are excluded) and assert each defines a fully resolvable __all__. - Cross-check each documented subpackage's __all__ against api.rst, handling both the dotted (graph.Graph) and flat (currentmodule) doc conventions. system is documented in api_nvml.rst, so its doc cross-check is skipped. * test(core): parse API docs with docutils * Update content to pass current tests * Add docutils dependency to pyproject.toml * Simplify checks. No longer make sure that everything documented is public. * test(core): document intentional scope limits of api docs consistency check * Reorganize __all__ * Fix doc reference * Address findings in PR * Fix tests and make __all__ construction consistent * test(core): drop IPC types from _memory package contents expectation _ipc.__all__ is now empty, so `from cuda.core._memory import *` no longer binds IPCAllocationHandle or IPCBufferDescriptor. Update the expected list in test_package_contents to match. Signed-off-by: Aryan --------- Signed-off-by: Aryan Co-authored-by: Michael Droettboom Co-authored-by: Michael Droettboom --- cuda_core/cuda/core/__init__.py | 84 +++--- cuda_core/cuda/core/_device.pyi | 3 +- cuda_core/cuda/core/_device.pyx | 2 + cuda_core/cuda/core/_event.pyi | 1 + cuda_core/cuda/core/_event.pyx | 2 + cuda_core/cuda/core/_host.py | 2 + cuda_core/cuda/core/_launch_config.pyi | 1 + cuda_core/cuda/core/_launch_config.pyx | 2 + cuda_core/cuda/core/_launcher.pyi | 1 + cuda_core/cuda/core/_launcher.pyx | 2 + cuda_core/cuda/core/_memory/__init__.py | 25 +- cuda_core/cuda/core/_memory/_ipc.pyi | 2 +- cuda_core/cuda/core/_memory/_ipc.pyx | 2 +- .../cuda/core/_memory/_managed_buffer.py | 2 + cuda_core/cuda/core/_stream.pyi | 1 + cuda_core/cuda/core/_stream.pyx | 3 + cuda_core/cuda/core/_tensor_map.pyi | 1 + cuda_core/cuda/core/_tensor_map.pyx | 2 + cuda_core/cuda/core/graph/__init__.py | 12 + cuda_core/cuda/core/system/__init__.py | 3 +- cuda_core/docs/source/api_nvml.rst | 8 + cuda_core/docs/source/api_private.rst | 36 ++- cuda_core/pixi.toml | 1 + cuda_core/pyproject.toml | 1 + cuda_core/tests/memory_ipc/test_errors.py | 2 +- cuda_core/tests/test_api_docs_consistency.py | 240 ++++++++++++++++++ cuda_core/tests/test_memory.py | 4 +- 27 files changed, 395 insertions(+), 50 deletions(-) create mode 100644 cuda_core/tests/test_api_docs_consistency.py diff --git a/cuda_core/cuda/core/__init__.py b/cuda_core/cuda/core/__init__.py index dc6fefdffea..b9a36e3dee7 100644 --- a/cuda_core/cuda/core/__init__.py +++ b/cuda_core/cuda/core/__init__.py @@ -69,45 +69,51 @@ class _PatchedProperty(metaclass=_PatchedPropMeta): from cuda.core import checkpoint, system, utils -from cuda.core._context import Context, ContextOptions -from cuda.core._device import Device -from cuda.core._device_resources import ( - DeviceResources, - SMResource, - SMResourceOptions, - WorkqueueResource, - WorkqueueResourceOptions, -) -from cuda.core._event import Event, EventOptions -from cuda.core._graphics import GraphicsResource -from cuda.core._host import Host -from cuda.core._launch_config import LaunchConfig -from cuda.core._launcher import launch -from cuda.core._linker import Linker, LinkerOptions -from cuda.core._memory import ( - Buffer, - DeviceMemoryResource, - DeviceMemoryResourceOptions, - GraphMemoryResource, - LegacyPinnedMemoryResource, - ManagedBuffer, - ManagedMemoryResource, - ManagedMemoryResourceOptions, - MemoryResource, - PinnedMemoryResource, - PinnedMemoryResourceOptions, - VirtualMemoryResource, - VirtualMemoryResourceOptions, -) -from cuda.core._module import Kernel, ObjectCode -from cuda.core._program import Program, ProgramOptions -from cuda.core._stream import ( - LEGACY_DEFAULT_STREAM, - PER_THREAD_DEFAULT_STREAM, - Stream, - StreamOptions, -) -from cuda.core._tensor_map import TensorMapDescriptor, TensorMapDescriptorOptions +from cuda.core._context import * +from cuda.core._context import __all__ as _context_all +from cuda.core._device import * +from cuda.core._device import __all__ as _device_all +from cuda.core._device_resources import * +from cuda.core._device_resources import __all__ as _device_resources_all +from cuda.core._event import * +from cuda.core._event import __all__ as _event_all +from cuda.core._graphics import * +from cuda.core._graphics import __all__ as _graphics_all +from cuda.core._host import * +from cuda.core._host import __all__ as _host_all +from cuda.core._launch_config import * +from cuda.core._launch_config import __all__ as _launch_config_all +from cuda.core._launcher import * +from cuda.core._launcher import __all__ as _launcher_all +from cuda.core._linker import * +from cuda.core._linker import __all__ as _linker_all +from cuda.core._memory import * +from cuda.core._memory import __all__ as _memory_all +from cuda.core._module import * +from cuda.core._module import __all__ as _module_all +from cuda.core._program import * +from cuda.core._program import __all__ as _program_all +from cuda.core._stream import * +from cuda.core._stream import __all__ as _stream_all +from cuda.core._tensor_map import * +from cuda.core._tensor_map import __all__ as _tensor_map_all + +__all__ = [ + *_context_all, + *_device_all, + *_device_resources_all, + *_event_all, + *_graphics_all, + *_host_all, + *_launch_config_all, + *_launcher_all, + *_linker_all, + *_memory_all, + *_module_all, + *_program_all, + *_stream_all, + *_tensor_map_all, +] # isort: split # Texture/surface types live under the cuda.core.texture namespace (not the diff --git a/cuda_core/cuda/core/_device.pyi b/cuda_core/cuda/core/_device.pyi index 14893fbd3c0..e83aef8a8d0 100644 --- a/cuda_core/cuda/core/_device.pyi +++ b/cuda_core/cuda/core/_device.pyi @@ -1023,4 +1023,5 @@ class Device: .. versionadded:: 1.1.0 """ _tls = threading.local() -_lock = threading.Lock() \ No newline at end of file +_lock = threading.Lock() +__all__ = ['Device'] \ No newline at end of file diff --git a/cuda_core/cuda/core/_device.pyx b/cuda_core/cuda/core/_device.pyx index 3c04413db0b..9c35fc9355b 100644 --- a/cuda_core/cuda/core/_device.pyx +++ b/cuda_core/cuda/core/_device.pyx @@ -61,6 +61,8 @@ _tls = threading.local() _lock = threading.Lock() cdef bint _is_cuInit = False +__all__ = ['Device'] + cdef class DeviceProperties: """ diff --git a/cuda_core/cuda/core/_event.pyi b/cuda_core/cuda/core/_event.pyi index 1ea91308bc1..9391735b6ab 100644 --- a/cuda_core/cuda/core/_event.pyi +++ b/cuda_core/cuda/core/_event.pyi @@ -180,6 +180,7 @@ class IPCEventDescriptor: def __reduce__(self) -> tuple[object, ...]: ... +__all__ = ['Event', 'EventOptions'] def _reduce_event(event: Event) -> tuple[object, ...]: ... \ No newline at end of file diff --git a/cuda_core/cuda/core/_event.pyx b/cuda_core/cuda/core/_event.pyx index e5cb81ac41e..314347f6cce 100644 --- a/cuda_core/cuda/core/_event.pyx +++ b/cuda_core/cuda/core/_event.pyx @@ -43,6 +43,8 @@ if TYPE_CHECKING: import cuda.bindings.driver # no-cython-lint from cuda.core._device import Device +__all__ = ['Event', 'EventOptions'] + @dataclass cdef class EventOptions: diff --git a/cuda_core/cuda/core/_host.py b/cuda_core/cuda/core/_host.py index e74743d493a..30464409871 100644 --- a/cuda_core/cuda/core/_host.py +++ b/cuda_core/cuda/core/_host.py @@ -6,6 +6,8 @@ import threading from typing import ClassVar +__all__ = ["Host"] + class Host: """Host (CPU) location for managed-memory operations. diff --git a/cuda_core/cuda/core/_launch_config.pyi b/cuda_core/cuda/core/_launch_config.pyi index eac16c1878f..bb47f1901a8 100644 --- a/cuda_core/cuda/core/_launch_config.pyi +++ b/cuda_core/cuda/core/_launch_config.pyi @@ -66,6 +66,7 @@ class LaunchConfig: def __hash__(self) -> int: ... _LAUNCH_CONFIG_ATTRS = ('grid', 'cluster', 'block', 'shmem_size', 'is_cooperative') +__all__ = ['LaunchConfig'] def _to_native_launch_config(config: LaunchConfig) -> object: """Convert LaunchConfig to native driver CUlaunchConfig. diff --git a/cuda_core/cuda/core/_launch_config.pyx b/cuda_core/cuda/core/_launch_config.pyx index a92ecf1f9e3..44dbe2f1cbf 100644 --- a/cuda_core/cuda/core/_launch_config.pyx +++ b/cuda_core/cuda/core/_launch_config.pyx @@ -15,6 +15,8 @@ from cuda.core._utils.cuda_utils import ( _LAUNCH_CONFIG_ATTRS = ('grid', 'cluster', 'block', 'shmem_size', 'is_cooperative') +__all__ = ['LaunchConfig'] + cdef class LaunchConfig: """Customizable launch options. diff --git a/cuda_core/cuda/core/_launcher.pyi b/cuda_core/cuda/core/_launcher.pyi index a292c3eec95..27ed7e86da7 100644 --- a/cuda_core/cuda/core/_launcher.pyi +++ b/cuda_core/cuda/core/_launcher.pyi @@ -8,6 +8,7 @@ from cuda.core._stream import Stream from cuda.core.graph import GraphBuilder from cuda.core.typing import IsStreamType +__all__ = ['launch'] def launch(stream: Stream | GraphBuilder | IsStreamType, config: LaunchConfig, kernel: Kernel, *kernel_args) -> None: """Launches a :obj:`~_module.Kernel` diff --git a/cuda_core/cuda/core/_launcher.pyx b/cuda_core/cuda/core/_launcher.pyx index d5ddaff4d56..036189790e0 100644 --- a/cuda_core/cuda/core/_launcher.pyx +++ b/cuda_core/cuda/core/_launcher.pyx @@ -24,6 +24,8 @@ if TYPE_CHECKING: from cuda.core.graph import GraphBuilder from cuda.core.typing import IsStreamType +__all__ = ['launch'] + def launch( stream: Stream | GraphBuilder | IsStreamType, diff --git a/cuda_core/cuda/core/_memory/__init__.py b/cuda_core/cuda/core/_memory/__init__.py index bf40a643f8c..d35ee814449 100644 --- a/cuda_core/cuda/core/_memory/__init__.py +++ b/cuda_core/cuda/core/_memory/__init__.py @@ -1,13 +1,34 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # # SPDX-License-Identifier: Apache-2.0 from ._buffer import * +from ._buffer import __all__ as _buffer_all from ._device_memory_resource import * +from ._device_memory_resource import __all__ as _device_memory_resource_all from ._graph_memory_resource import * +from ._graph_memory_resource import __all__ as _graph_memory_resource_all from ._ipc import * +from ._ipc import __all__ as _ipc_all from ._legacy import * -from ._managed_buffer import ManagedBuffer +from ._legacy import __all__ as _legacy_all +from ._managed_buffer import * +from ._managed_buffer import __all__ as _managed_buffer_all from ._managed_memory_resource import * +from ._managed_memory_resource import __all__ as _managed_memory_resource_all from ._pinned_memory_resource import * +from ._pinned_memory_resource import __all__ as _pinned_memory_resource_all from ._virtual_memory_resource import * +from ._virtual_memory_resource import __all__ as _virtual_memory_resource_all + +__all__ = [ + *_buffer_all, + *_device_memory_resource_all, + *_graph_memory_resource_all, + *_ipc_all, + *_legacy_all, + *_managed_buffer_all, + *_managed_memory_resource_all, + *_pinned_memory_resource_all, + *_virtual_memory_resource_all, +] diff --git a/cuda_core/cuda/core/_memory/_ipc.pyi b/cuda_core/cuda/core/_memory/_ipc.pyi index 0c912a567bd..7c707ab0418 100644 --- a/cuda_core/cuda/core/_memory/_ipc.pyi +++ b/cuda_core/cuda/core/_memory/_ipc.pyi @@ -84,7 +84,7 @@ class IPCAllocationHandle: @property def uuid(self) -> uuid.UUID: ... -__all__ = ['IPCBufferDescriptor', 'IPCAllocationHandle'] +__all__ = [] def _reduce_allocation_handle(alloc_handle: IPCAllocationHandle) -> tuple[object, ...]: ... diff --git a/cuda_core/cuda/core/_memory/_ipc.pyx b/cuda_core/cuda/core/_memory/_ipc.pyx index d03f51a26ce..f4194b22b0e 100644 --- a/cuda_core/cuda/core/_memory/_ipc.pyx +++ b/cuda_core/cuda/core/_memory/_ipc.pyx @@ -29,7 +29,7 @@ import platform import uuid import weakref -__all__ = ['IPCBufferDescriptor', 'IPCAllocationHandle'] +__all__ = [] cdef object registry = weakref.WeakValueDictionary() diff --git a/cuda_core/cuda/core/_memory/_managed_buffer.py b/cuda_core/cuda/core/_memory/_managed_buffer.py index 9a8333e7094..83a6c618864 100644 --- a/cuda_core/cuda/core/_memory/_managed_buffer.py +++ b/cuda_core/cuda/core/_memory/_managed_buffer.py @@ -25,6 +25,8 @@ from cuda.core._stream import Stream from cuda.core.graph import GraphBuilder +__all__ = ["ManagedBuffer"] + _INT_SIZE = 4 diff --git a/cuda_core/cuda/core/_stream.pyi b/cuda_core/cuda/core/_stream.pyi index f4d78982a1d..efdcca29256 100644 --- a/cuda_core/cuda/core/_stream.pyi +++ b/cuda_core/cuda/core/_stream.pyi @@ -212,6 +212,7 @@ class Stream: Newly created graph builder object. """ +__all__ = ['LEGACY_DEFAULT_STREAM', 'PER_THREAD_DEFAULT_STREAM', 'Stream', 'StreamOptions'] LEGACY_DEFAULT_STREAM: Stream = Stream._legacy_default() PER_THREAD_DEFAULT_STREAM: Stream = Stream._per_thread_default() diff --git a/cuda_core/cuda/core/_stream.pyx b/cuda_core/cuda/core/_stream.pyx index 21d6e27b5e6..e768f6469f0 100644 --- a/cuda_core/cuda/core/_stream.pyx +++ b/cuda_core/cuda/core/_stream.pyx @@ -47,6 +47,9 @@ if TYPE_CHECKING: from cuda.core._device import Device from cuda.core.graph import GraphBuilder +__all__ = ['LEGACY_DEFAULT_STREAM', 'PER_THREAD_DEFAULT_STREAM', 'Stream', 'StreamOptions'] + + @dataclass cdef class StreamOptions: """Customizable :obj:`~_stream.Stream` options. diff --git a/cuda_core/cuda/core/_tensor_map.pyi b/cuda_core/cuda/core/_tensor_map.pyi index 986ab41549f..c6a18ad2399 100644 --- a/cuda_core/cuda/core/_tensor_map.pyi +++ b/cuda_core/cuda/core/_tensor_map.pyi @@ -284,6 +284,7 @@ class TensorMapDescriptor: def __repr__(self) -> str: ... +__all__ = ['TensorMapDescriptor', 'TensorMapDescriptorOptions'] _TMA_DT_UINT8 = int(cydriver.CU_TENSOR_MAP_DATA_TYPE_UINT8) _TMA_DT_UINT16 = int(cydriver.CU_TENSOR_MAP_DATA_TYPE_UINT16) _TMA_DT_UINT32 = int(cydriver.CU_TENSOR_MAP_DATA_TYPE_UINT32) diff --git a/cuda_core/cuda/core/_tensor_map.pyx b/cuda_core/cuda/core/_tensor_map.pyx index b3cdb0b401a..46c2fa93152 100644 --- a/cuda_core/cuda/core/_tensor_map.pyx +++ b/cuda_core/cuda/core/_tensor_map.pyx @@ -47,6 +47,8 @@ try: except ImportError: ml_bfloat16 = None +__all__ = ['TensorMapDescriptor', 'TensorMapDescriptorOptions'] + class TensorMapDataType(enum.IntEnum): """Data types for tensor map descriptors. diff --git a/cuda_core/cuda/core/graph/__init__.py b/cuda_core/cuda/core/graph/__init__.py index e1091114368..507888321ea 100644 --- a/cuda_core/cuda/core/graph/__init__.py +++ b/cuda_core/cuda/core/graph/__init__.py @@ -2,7 +2,19 @@ # # SPDX-License-Identifier: Apache-2.0 +from . import _graph_builder, _graph_definition, _graph_node, _subclasses from ._graph_builder import * from ._graph_definition import * from ._graph_node import * from ._subclasses import * + +# Aggregate the star-imported submodule exports so ``cuda.core.graph`` carries +# an explicit ``__all__`` derived from its parts (no manual list to drift). +__all__ = [ + *_graph_builder.__all__, + *_graph_definition.__all__, + *_graph_node.__all__, + *_subclasses.__all__, +] + +del _graph_builder, _graph_definition, _graph_node, _subclasses diff --git a/cuda_core/cuda/core/system/__init__.py b/cuda_core/cuda/core/system/__init__.py index 685519f9b80..acb648549bc 100644 --- a/cuda_core/cuda/core/system/__init__.py +++ b/cuda_core/cuda/core/system/__init__.py @@ -12,8 +12,10 @@ __all__ = [ "CUDA_BINDINGS_NVML_IS_COMPATIBLE", + "get_driver_branch", "get_kernel_mode_driver_version", "get_num_devices", + "get_nvml_version", "get_process_name", "get_user_mode_driver_version", ] @@ -40,7 +42,6 @@ from .exceptions import * from .exceptions import __all__ as _exceptions_all - __all__.append("get_nvml_version") __all__.extend(_device_all) __all__.extend(_system_events_all) __all__.extend(_exceptions_all) diff --git a/cuda_core/docs/source/api_nvml.rst b/cuda_core/docs/source/api_nvml.rst index 7780dd6086e..c96b68ab701 100644 --- a/cuda_core/docs/source/api_nvml.rst +++ b/cuda_core/docs/source/api_nvml.rst @@ -45,3 +45,11 @@ Types Device NvlinkInfo + +Constants +--------- + +.. autosummary:: + :toctree: generated/ + + CUDA_BINDINGS_NVML_IS_COMPATIBLE diff --git a/cuda_core/docs/source/api_private.rst b/cuda_core/docs/source/api_private.rst index 907fc2f5bcf..80675799c07 100644 --- a/cuda_core/docs/source/api_private.rst +++ b/cuda_core/docs/source/api_private.rst @@ -40,11 +40,12 @@ CUDA runtime typing.VirtualMemoryGranularityType typing.VirtualMemoryHandleType typing.VirtualMemoryLocationType + typing.WorkqueueSharingScopeType :template: autosummary/cyclass.rst + DeviceResources _device.DeviceProperties - _device_resources.DeviceResources _memory._ipc.IPCAllocationHandle _memory._ipc.IPCBufferDescriptor _memory._managed_buffer.AccessedBySetProxy @@ -125,3 +126,36 @@ NVML system.typing.TemperatureThresholds system.typing.ThermalController system.typing.ThermalTarget + + system.NvmlError + system.UninitializedError + system.InvalidArgumentError + system.NotSupportedError + system.NoPermissionError + system.AlreadyInitializedError + system.NotFoundError + system.InsufficientSizeError + system.InsufficientPowerError + system.DriverNotLoadedError + system.TimeoutError + system.IrqIssueError + system.LibraryNotFoundError + system.FunctionNotFoundError + system.CorruptedInforomError + system.GpuIsLostError + system.ResetRequiredError + system.OperatingSystemError + system.LibRmVersionMismatchError + system.InUseError + system.MemoryError + system.NoDataError + system.VgpuEccNotSupportedError + system.InsufficientResourcesError + system.FreqNotSupportedError + system.ArgumentVersionMismatchError + system.DeprecatedError + system.NotReadyError + system.GpuNotFoundError + system.InvalidStateError + system.ResetTypeNotSupportedError + system.UnknownError diff --git a/cuda_core/pixi.toml b/cuda_core/pixi.toml index 8772ed4e88b..30767983ba1 100644 --- a/cuda_core/pixi.toml +++ b/cuda_core/pixi.toml @@ -21,6 +21,7 @@ pytest-randomly = "*" pytest-repeat = "*" pytest-rerunfailures = "*" cloudpickle = "*" +docutils = "*" psutil = "*" pyglet = "*" diff --git a/cuda_core/pyproject.toml b/cuda_core/pyproject.toml index f3a0c3a70f9..2c6435e4957 100644 --- a/cuda_core/pyproject.toml +++ b/cuda_core/pyproject.toml @@ -69,6 +69,7 @@ test = [ "pytest-timeout==2.4.0", "cloudpickle==3.1.2", "psutil==7.2.2", + "docutils==0.23", # TODO: remove the Python 3.15 guard once 3.15 is officially supported "cffi==2.0.0; python_version < '3.15'", ] diff --git a/cuda_core/tests/memory_ipc/test_errors.py b/cuda_core/tests/memory_ipc/test_errors.py index 40cbcc2826b..40162fab01d 100644 --- a/cuda_core/tests/memory_ipc/test_errors.py +++ b/cuda_core/tests/memory_ipc/test_errors.py @@ -9,7 +9,7 @@ from helpers.child_processes import child_timeout_sec, kill_subprocesses from cuda.core import Buffer, Device, DeviceMemoryResource, DeviceMemoryResourceOptions -from cuda.core._memory import IPCBufferDescriptor +from cuda.core._memory._ipc import IPCBufferDescriptor from cuda.core._utils.cuda_utils import CUDAError CHILD_TIMEOUT_SEC = child_timeout_sec() diff --git a/cuda_core/tests/test_api_docs_consistency.py b/cuda_core/tests/test_api_docs_consistency.py new file mode 100644 index 00000000000..053fc93d6cd --- /dev/null +++ b/cuda_core/tests/test_api_docs_consistency.py @@ -0,0 +1,240 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +"""Consistency checks between the public ``__all__`` surface and the API docs. + +Covers the flat ``cuda.core`` namespace and every public submodule +(``checkpoint``, ``graph``, ``system``, ``texture``, ``typing``, ``utils``, +and any added later) discovered automatically from ``cuda.core.__path__``. +For each public namespace, exported ``__all__`` names must appear somewhere +in ``cuda_core/docs/source``. + +The enforced direction is deliberately one-way (public export -> documented). +This is intentionally a *name-presence* check, and it does not verify: + +- the reverse direction (documented -> exported): documenting a private or + internal symbol on any page is allowed, so a documented name is never + required to be public; +- signatures, docstrings, parameter lists, or rendered output: only that each + exported name appears as a documented entry; +- whether an entry is marked ``:no-index:`` or deprecated: such entries still + count as documented; +- class members or attributes nested below the namespace level: only top-level + names of each namespace are matched (entries deeper than + ``.`` are ignored); +- docs outside the top-level ``docs/source/*.rst`` files: nested pages are not + scanned. +""" + +import collections +import importlib +import io +import pathlib +import pkgutil +import re + +import pytest +from docutils import nodes +from docutils.core import publish_doctree +from docutils.parsers.rst import Directive, directives + +import cuda.core + +DOCS_SOURCE_DIR = pathlib.Path(__file__).resolve().parent.parent / "docs" / "source" + +# ``cuda.core`` ships a versioned wheel shim as ``cu12`` / ``cu13`` subpackages; +# those are an internal packaging mechanism, not public API. +_VERSIONED_SUBPACKAGE = re.compile(r"^cu\d+$") + +PUBLIC_SUBMODULES = sorted( + name + for _, name, ispkg in pkgutil.iter_modules(cuda.core.__path__) + if not name.startswith("_") and not _VERSIONED_SUBPACKAGE.match(name) +) + + +class _ModuleNode(nodes.Element): + pass + + +class _AutosummaryNode(nodes.Element): + pass + + +class _DataNode(nodes.Element): + pass + + +class _ModuleDirective(Directive): + required_arguments = 1 + final_argument_whitespace = False + has_content = True + option_spec = { + "deprecated": directives.unchanged, + "no-index": directives.flag, + "platform": directives.unchanged, + "synopsis": directives.unchanged, + } + + def run(self): + node = _ModuleNode() + node["module"] = self.arguments[0].strip() + self.state.nested_parse(self.content, self.content_offset, node) + return [node] + + +class _AutosummaryDirective(Directive): + has_content = True + option_spec = { + "caption": directives.unchanged, + "nosignatures": directives.flag, + "recursive": directives.flag, + "template": directives.unchanged, + "toctree": directives.unchanged, + } + + def run(self): + node = _AutosummaryNode() + node["entries"] = [entry for line in self.content if (entry := line.strip()) and not entry.startswith(":")] + return [node] + + +class _DataDirective(Directive): + required_arguments = 1 + final_argument_whitespace = True + has_content = True + option_spec = { + "annotation": directives.unchanged, + "no-index": directives.flag, + "type": directives.unchanged, + "value": directives.unchanged, + } + + def run(self): + node = _DataNode() + node["name"] = self.arguments[0].strip() + return [node] + + +# These patch the global docutils directive registry for the process lifetime. +# Safe as long as no other test module in the same session uses docutils or +# Sphinx with the real autosummary/module/data directives. If that ever changes, +# move these calls into a session-scoped autouse fixture that saves and restores +# the previous mapping. +directives.register_directive("autosummary", _AutosummaryDirective) +directives.register_directive("currentmodule", _ModuleDirective) +directives.register_directive("data", _DataDirective) +directives.register_directive("module", _ModuleDirective) + + +def _iter_documented_entries(rst_path): + """Yield (module, entry) pairs from Sphinx directives in an RST file.""" + doctree = publish_doctree( + rst_path.read_text(), + source_path=str(rst_path), + settings_overrides={ + "halt_level": 6, + "report_level": 5, + "warning_stream": io.StringIO(), + }, + ) + module = None + for node in doctree.findall(): + if isinstance(node, _ModuleNode): + module = node["module"] + elif isinstance(node, _AutosummaryNode): + for entry in node["entries"]: + yield module, entry + elif isinstance(node, _DataNode): + yield module, node["name"] + + +def _add_documented_name(documented, module, entry): + if not module or not module.startswith("cuda.core"): + return + if module == "cuda.core": + if "." not in entry: + documented[module].add(entry) + return + sub, name = entry.split(".", 1) + if sub in PUBLIC_SUBMODULES and "." not in name: + documented[f"cuda.core.{sub}"].add(name) + return + if module.startswith("cuda.core."): + namespace = module + if namespace in PUBLIC_NAMESPACES and "." not in entry: + documented[namespace].add(entry) + + +def _documented_names(docs_dir, *, exclude=frozenset()): + documented = collections.defaultdict(set) + for rst_path in docs_dir.glob("*.rst"): + if rst_path.name in exclude: + continue + for module, entry in _iter_documented_entries(rst_path): + _add_documented_name(documented, module, entry) + return documented + + +PUBLIC_NAMESPACES = ("cuda.core", *(f"cuda.core.{sub}" for sub in PUBLIC_SUBMODULES)) + + +@pytest.fixture(scope="module") +def exported(): + if not hasattr(cuda.core, "__all__"): + pytest.skip("cuda.core does not define __all__") + return set(cuda.core.__all__) + + +@pytest.fixture(scope="module") +def docs_dir(): + if not DOCS_SOURCE_DIR.is_dir(): + pytest.skip("docs sources not available (not running from a source checkout)") + return DOCS_SOURCE_DIR + + +@pytest.fixture(scope="module") +def documented(docs_dir): + return _documented_names(docs_dir) + + +@pytest.mark.human_authored +def test_public_submodules_discovered(): + # Guards against a broken __path__ walk silently turning every + # parametrized submodule check into a no-op. + assert PUBLIC_SUBMODULES, "no public cuda.core submodules were discovered" + + +@pytest.mark.human_authored +def test_main_package_all_exports_resolve(): + assert hasattr(cuda.core, "__all__"), "cuda.core does not define __all__" + missing = [name for name in cuda.core.__all__ if not hasattr(cuda.core, name)] + assert missing == [], f"cuda.core.__all__ lists names that do not resolve: {missing}" + + +@pytest.mark.human_authored +def test_main_package_symbols_are_documented(exported, documented): + documented = documented["cuda.core"] + undocumented = exported - documented + assert not undocumented, f"public by cuda.core.__all__ but missing from docs/source/*.rst: {sorted(undocumented)}" + + +@pytest.mark.parametrize("sub", PUBLIC_SUBMODULES) +def test_subpackage_symbols_define_all(sub): + module = importlib.import_module(f"cuda.core.{sub}") + assert hasattr(module, "__all__"), f"cuda.core.{sub} does not define __all__" + missing = [name for name in module.__all__ if not hasattr(module, name)] + assert missing == [], f"cuda.core.{sub}.__all__ lists names that do not resolve: {missing}" + + +@pytest.mark.human_authored +@pytest.mark.parametrize("sub", PUBLIC_SUBMODULES) +def test_subpackage_exports_are_documented(sub, documented): + documented = documented[f"cuda.core.{sub}"] + module = importlib.import_module(f"cuda.core.{sub}") + exported = set(module.__all__) + undocumented = exported - documented + assert not undocumented, ( + f"public by cuda.core.{sub}.__all__ but missing from docs/source/*.rst: {sorted(undocumented)}" + ) diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index c02a88e4a28..4427b899765 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -42,7 +42,7 @@ system as ccx_system, ) from cuda.core._dlpack import DLDeviceType -from cuda.core._memory import IPCBufferDescriptor +from cuda.core._memory._ipc import IPCBufferDescriptor from cuda.core._utils.cuda_utils import CUDAError, handle_return from cuda.core.typing import ( ManagedMemoryLocationType, @@ -136,8 +136,6 @@ def test_package_contents(): "DeviceMemoryResource", "DeviceMemoryResourceOptions", "GraphMemoryResource", - "IPCAllocationHandle", - "IPCBufferDescriptor", "LegacyPinnedMemoryResource", "ManagedBuffer", "ManagedMemoryResource", From 41725b240596a17a1ad4dcee49fc84091156bbf9 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Wed, 29 Jul 2026 11:23:43 -0400 Subject: [PATCH 05/50] Check for release notes on the tagged commit (#2446) --- .github/workflows/release.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 37322974a02..4f2c54f4509 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -158,6 +158,8 @@ jobs: steps: - name: Checkout Source uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + ref: ${{ inputs.git-tag }} - name: Set up Python uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 From 97df94ce5811c73bd9cbbc964c04ab4eb5af9399 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Wed, 29 Jul 2026 14:47:13 -0400 Subject: [PATCH 06/50] Fix version parsing in cuda_core; Allow new enums to be added to cuda_bindings (#2451) * Fix version parsing in cuda_core * Fix enum checks --- .../core/_utils/enum_explanations_helpers.py | 17 ++++++++++--- cuda_core/cuda/core/_utils/version.pyi | 8 ++++++ cuda_core/cuda/core/_utils/version.pyx | 19 +++++++++++--- cuda_core/tests/test_enum_coverage.py | 25 +++++++++++++------ 4 files changed, 55 insertions(+), 14 deletions(-) diff --git a/cuda_core/cuda/core/_utils/enum_explanations_helpers.py b/cuda_core/cuda/core/_utils/enum_explanations_helpers.py index 0dbe6d6bb60..6b666f4536c 100644 --- a/cuda_core/cuda/core/_utils/enum_explanations_helpers.py +++ b/cuda_core/cuda/core/_utils/enum_explanations_helpers.py @@ -31,6 +31,18 @@ _ExplanationTableLoader = Callable[[], _ExplanationTable] +def _parse_version_triple(version_str: str) -> tuple[int, int, int]: + """Parse a PEP 440 version string into a (major, minor, patch) triple. + + Strips local-version identifiers and handles pre-release suffixes such as + ``0b1`` or ``0rc1`` by extracting only the leading integer from each + release segment. + """ + parts = version_str.partition("+")[0].split(".")[:3] + ints = ([int(m.group(1)) if (m := re.match(r"(\d+)", v)) else 0 for v in parts] + [0, 0, 0])[:3] + return (ints[0], ints[1], ints[2]) + + # ``version.pyx`` cannot be reused here (circular import via ``cuda_utils``). def _binding_version() -> tuple[int, int, int]: """Return the installed ``cuda-bindings`` version, or a conservative old value.""" @@ -38,10 +50,7 @@ def _binding_version() -> tuple[int, int, int]: version = importlib.metadata.version("cuda-bindings") except importlib.metadata.PackageNotFoundError: return (0, 0, 0) # For very old versions of cuda-python - - parts = version.partition("+")[0].split(".")[:3] - parts_int = ([int(v) for v in parts] + [0, 0, 0])[:3] - return (parts_int[0], parts_int[1], parts_int[2]) + return _parse_version_triple(version) def _binding_version_has_usable_enum_docstrings(version: tuple[int, int, int]) -> bool: diff --git a/cuda_core/cuda/core/_utils/version.pyi b/cuda_core/cuda/core/_utils/version.pyi index bb7f0129917..a577e037bf7 100644 --- a/cuda_core/cuda/core/_utils/version.pyi +++ b/cuda_core/cuda/core/_utils/version.pyi @@ -5,6 +5,14 @@ from __future__ import annotations import functools +def _parse_version_triple(version_str: str) -> tuple[int, int, int]: + """Parse a PEP 440 version string into a (major, minor, patch) triple. + + Strips local-version identifiers and handles pre-release suffixes such as + ``0b1`` or ``0rc1`` by extracting only the leading integer from each + release segment. + """ + @functools.cache def binding_version() -> tuple[int, int, int]: """Return the cuda-bindings version as a (major, minor, patch) triple.""" diff --git a/cuda_core/cuda/core/_utils/version.pyx b/cuda_core/cuda/core/_utils/version.pyx index 09ea5852421..ed4c93c0262 100644 --- a/cuda_core/cuda/core/_utils/version.pyx +++ b/cuda_core/cuda/core/_utils/version.pyx @@ -4,18 +4,31 @@ import functools import importlib.metadata +import re from cuda.core._utils.cuda_utils import driver, handle_return +def _parse_version_triple(version_str: str) -> tuple[int, int, int]: + """Parse a PEP 440 version string into a (major, minor, patch) triple. + + Strips local-version identifiers and handles pre-release suffixes such as + ``0b1`` or ``0rc1`` by extracting only the leading integer from each + release segment. + """ + parts = version_str.partition("+")[0].split(".")[:3] + ints = ([int(m.group(1)) if (m := re.match(r"(\d+)", v)) else 0 for v in parts] + [0, 0, 0])[:3] + return (ints[0], ints[1], ints[2]) + + @functools.cache def binding_version() -> tuple[int, int, int]: """Return the cuda-bindings version as a (major, minor, patch) triple.""" try: - parts = importlib.metadata.version("cuda-bindings").split(".")[:3] + version_str = importlib.metadata.version("cuda-bindings") except importlib.metadata.PackageNotFoundError: - parts = importlib.metadata.version("cuda-python").split(".")[:3] - return tuple(int(v) for v in parts) + version_str = importlib.metadata.version("cuda-python") + return _parse_version_triple(version_str) @functools.cache diff --git a/cuda_core/tests/test_enum_coverage.py b/cuda_core/tests/test_enum_coverage.py index 8de26b25d4b..aa537177c7d 100644 --- a/cuda_core/tests/test_enum_coverage.py +++ b/cuda_core/tests/test_enum_coverage.py @@ -344,8 +344,16 @@ def test_wrapper_covers_all_binding_members(binding, str_enum, mapping, binding_ # Compare by integer value so that enum aliases (two names, one integer) # are treated as covered when the canonical member appears in the mapping. covered_values = frozenset(int(m) for m in (*mapping.keys(), *mapping.values()) if isinstance(m, binding)) - missing = {name for name in required if int(binding.__members__[name]) not in covered_values} - assert not missing, f"{binding.__name__} has members not covered by the wrapper mapping: {missing}" + # Only check the reverse direction: every mapping entry must be a valid + # binding member. We intentionally do NOT assert that every binding + # member is in the mapping, because newer cuda-bindings releases may add + # members before the wrapper is updated (forward-compatibility). + invalid = { + name + for name in binding_unmapped + if name in binding.__members__ and int(binding.__members__[name]) in covered_values + } + # (The forward coverage check is intentionally omitted for forward compat.) # Reverse check: every StrEnum member must also appear in the mapping. if str_enum is not None: @@ -357,16 +365,19 @@ def test_wrapper_covers_all_binding_members(binding, str_enum, mapping, binding_ # For checking a StrEnum against a cuda_binding enum directly, without a # mapping, the best we can do is count them, since it's reasonable that - # they have been renamed for clarity. + # they have been renamed for clarity. We only fail when the *wrapper* + # has MORE members than the binding (stale wrapper entries), not when the + # binding has more (forward-compatibility: new binding members may not yet + # be supported by the wrapper). required_count = len(required) covered_str_enum = set(str_enum.__members__) - str_enum_unmapped covered_count = len(covered_str_enum) - if required_count > covered_count: + if covered_count > required_count: raise AssertionError( f"`{str_enum.__module__}.{str_enum.__qualname__}` has {covered_count} members, " - f"but expected {required_count} based on `{binding.__module__}.{binding.__qualname__}` " - "after accounting for unmapped members. This may indicate that some members are missing " - "from the wrapper, or that some wrapper members do not correspond to actual binding members." + f"but only {required_count} are present in `{binding.__module__}.{binding.__qualname__}` " + "after accounting for unmapped members. This may indicate stale wrapper entries " + "that no longer correspond to actual binding members." ) From 2a62ae83174b3469dcaebe3112c6414ab6e24439 Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Wed, 29 Jul 2026 11:54:59 -0700 Subject: [PATCH 07/50] chore: cython warnings as errors in cuda.core (#2441) * chore: -Werror for cythonization in cuda.core * chore: -Werror for cythonization in cuda.bindings * address review feedback * fix other cython warnings missed locally --- cuda_core/build_hooks.py | 2 ++ cuda_core/cuda/core/_memory/_memory_pool.pyx | 2 +- cuda_core/cuda/core/graph/_graph_node.pyx | 2 +- cuda_core/cuda/core/system/_device.pyi | 2 +- cuda_core/cuda/core/system/_device.pyx | 2 ++ cuda_core/cuda/core/system/_process.pxi | 2 +- 6 files changed, 8 insertions(+), 4 deletions(-) diff --git a/cuda_core/build_hooks.py b/cuda_core/build_hooks.py index dfd08d56733..4aec4981c53 100644 --- a/cuda_core/build_hooks.py +++ b/cuda_core/build_hooks.py @@ -17,6 +17,7 @@ from pathlib import Path from Cython.Build import cythonize +from Cython.Compiler import Options as _CythonOptions from setuptools import Extension from setuptools import build_meta as _build_meta @@ -212,6 +213,7 @@ def get_sources(mod_name): nthreads = int(os.environ.get("CUDA_PYTHON_PARALLEL_LEVEL", os.cpu_count() // 2)) compile_time_env = {"CUDA_CORE_BUILD_MAJOR": int(_determine_cuda_major_version())} compiler_directives = {"embedsignature": True, "warn.deprecated.IF": False, "freethreading_compatible": True} + _CythonOptions.warning_errors = True if COMPILE_FOR_COVERAGE: compiler_directives["linetrace"] = True _extensions = cythonize( diff --git a/cuda_core/cuda/core/_memory/_memory_pool.pyx b/cuda_core/cuda/core/_memory/_memory_pool.pyx index 2de31af42d7..fbb320e02ff 100644 --- a/cuda_core/cuda/core/_memory/_memory_pool.pyx +++ b/cuda_core/cuda/core/_memory/_memory_pool.pyx @@ -282,11 +282,11 @@ cdef int MP_init_current_pool( HANDLE_RETURN(cydriver.cuMemGetMemPool(&pool, &loc, alloc_type)) self._h_pool = create_mempool_handle_ref(pool) self._mempool_owned = False + return 0 ELSE: raise RuntimeError( "Getting the current memory pool requires CUDA 13.0 or later" ) - return 0 cdef int MP_raise_release_threshold(_MemPool self) except? -1: diff --git a/cuda_core/cuda/core/graph/_graph_node.pyx b/cuda_core/cuda/core/graph/_graph_node.pyx index bded8f5b61c..41ab9728b80 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyx +++ b/cuda_core/cuda/core/graph/_graph_node.pyx @@ -999,7 +999,7 @@ cdef inline MemcpyNode GN_memcpy( params.srcMemoryType = c_src_type params.dstMemoryType = c_dst_type if c_src_type == cydriver.CU_MEMORYTYPE_HOST: - params.srcHost = c_src + params.srcHost = c_src else: params.srcDevice = c_src if c_dst_type == cydriver.CU_MEMORYTYPE_HOST: diff --git a/cuda_core/cuda/core/system/_device.pyi b/cuda_core/cuda/core/system/_device.pyi index 0a51e5c9928..c758576f0ac 100644 --- a/cuda_core/cuda/core/system/_device.pyi +++ b/cuda_core/cuda/core/system/_device.pyi @@ -1036,7 +1036,7 @@ class ProcessInfo: Information about running compute processes on the GPU. """ - def __init__(self, device: 'Device', process_info: nvml.ProcessInfo): + def __init__(self, device: Device, process_info: nvml.ProcessInfo): ... @property diff --git a/cuda_core/cuda/core/system/_device.pyx b/cuda_core/cuda/core/system/_device.pyx index 73f51cad8e3..6c81c3b9732 100644 --- a/cuda_core/cuda/core/system/_device.pyx +++ b/cuda_core/cuda/core/system/_device.pyx @@ -2,6 +2,8 @@ # # SPDX-License-Identifier: Apache-2.0 +from __future__ import annotations + from libc.stdint cimport intptr_t, uint64_t from libc.math cimport ceil diff --git a/cuda_core/cuda/core/system/_process.pxi b/cuda_core/cuda/core/system/_process.pxi index 019ebf5c323..4266f5b5914 100644 --- a/cuda_core/cuda/core/system/_process.pxi +++ b/cuda_core/cuda/core/system/_process.pxi @@ -7,7 +7,7 @@ class ProcessInfo: """ Information about running compute processes on the GPU. """ - def __init__(self, device: "Device", process_info: nvml.ProcessInfo): + def __init__(self, device: Device, process_info: nvml.ProcessInfo): self._device = device self._process_info = process_info From ca14583f6bd8511ec2a7aed6cd097b18a491f9bd Mon Sep 17 00:00:00 2001 From: Bharat Raghunathan Date: Wed, 29 Jul 2026 14:27:31 -0500 Subject: [PATCH 08/50] [doc-only] docs: document setuptools-scm clone requirements for source builds (#2424) * docs: document setuptools-scm clone requirements for source builds Signed-off-by: Bharat Raghunathan * Applied review suggestions from @mdboom Signed-off-by: Bharat Raghunathan --------- Signed-off-by: Bharat Raghunathan --- CONTRIBUTING.md | 92 +++++++++++++++++++++++++ cuda_bindings/docs/source/install.rst | 3 + cuda_core/docs/source/install.rst | 16 ++++- cuda_pathfinder/docs/source/install.rst | 12 +++- 4 files changed, 119 insertions(+), 4 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 012126cc842..9f28ec49a38 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -19,6 +19,10 @@ Thank you for your interest in contributing to CUDA Python! Based on the type of - [Contributing to CUDA Python](#contributing-to-cuda-python) - [Table of Contents](#table-of-contents) + - [Cloning the repository](#cloning-the-repository) + - [Recommended clone](#recommended-clone) + - [Fixing an existing clone](#fixing-an-existing-clone) + - [Symptoms of a bad clone](#symptoms-of-a-bad-clone) - [Type stubs for cuda.core](#type-stubs-for-cudacore) - [Pre-commit](#pre-commit) - [Signing Your Work](#signing-your-work) @@ -34,6 +38,94 @@ Thank you for your interest in contributing to CUDA Python! Based on the type of - [Code coverage](#code-coverage) +## Cloning the repository + +Every package in this repository derives its version from git tags using +[`setuptools-scm`](https://setuptools-scm.readthedocs.io/), so **how you clone +determines whether you can build at all, and whether the version you build is +correct.** Each package matches its own tag prefix: + +| Package | Tag pattern | +| --- | --- | +| `cuda-bindings`, `cuda-python` | `v*` (e.g. `v13.3.1`) | +| `cuda-core` | `cuda-core-v*` (e.g. `cuda-core-v1.1.0`) | +| `cuda-pathfinder` | `cuda-pathfinder-v*` (e.g. `cuda-pathfinder-v1.6.0`) | + +Each package sets `root = ".."` in its `[tool.setuptools_scm]` table, meaning the +version is read from the *repository root* rather than the package directory. A +working build therefore needs all of the following: + +1. **A real git clone.** Source zips and GitHub "Download ZIP" archives have no + git metadata and the build fails outright. (Tarballs produced by + `git archive` do work, thanks to the `.git_archival.txt` substitutions + configured in `.gitattributes`.) +2. **The full repository**, not just the package subdirectory, because the + version lookup walks up to the repository root. +3. **Tags, reaching back at least as far as the most recent tag** matching the + package you are building. `git describe` needs to find that tag; the history + between it and your checkout must be present too. + +### Recommended clone + +The default `git clone` gives you everything you need: + +```console +$ git clone https://github.com/NVIDIA/cuda-python.git +``` + + + +### Fixing an existing clone + +If you already have a shallow clone: + +```console +$ git fetch --unshallow --tags +``` + +If you are working from a personal fork, your fork's tags stop tracking upstream +the moment new releases are cut, which silently yields a stale version. Fetch +tags from upstream directly: + +```console +$ git remote add upstream https://github.com/NVIDIA/cuda-python.git +$ git fetch --tags upstream +``` + +Keep doing this periodically — a fork that was correct when you created it will +drift. + +### Symptoms of a bad clone + +Only case 3 below reports an error. The first two fail *silently*, producing a +wrong version that surfaces much later as a confusing dependency-resolution or +version-check failure: + +1. **No tags reachable.** The build succeeds and produces a version starting at + `0.1.dev`: a `--depth 1` clone yields `0.1.dev1+g0d22cb444`, a full clone made + with `--no-tags` yields `0.1.dev2114+g0d22cb444`. Installing `cuda-python` + built this way then fails, because its `install_requires` pins + `cuda-bindings` to that same bogus version. +2. **Stale tags** (a fork that has not fetched upstream in a while): you get a + plausible-looking but wrong version, e.g. `13.0.4.dev650+g0d22cb44` when the + real latest tag is `v13.3.1`. Nothing warns you. Note there is no leading + `v` — the tag prefix is stripped by `tag_regex`. +3. **No git metadata** (source zip): the build fails with + `LookupError: setuptools-scm was unable to detect version`. + +As a last resort — for example when building inside a container that has no git +history — you can bypass the lookup entirely: + +```console +$ SETUPTOOLS_SCM_PRETEND_VERSION_FOR_CUDA_CORE=1.1.0 pip install ./cuda_core +``` + +The environment variable is suffixed with the distribution name, uppercased with +hyphens replaced by underscores: `..._FOR_CUDA_BINDINGS`, `..._FOR_CUDA_CORE`, +`..._FOR_CUDA_PATHFINDER`, `..._FOR_CUDA_PYTHON`. Use this only when you +genuinely cannot provide tags; it is not a substitute for a correct clone. + + ## Type stubs for cuda.core `cuda.core` is a PEP 561-compliant package: it ships a `py.typed` marker and diff --git a/cuda_bindings/docs/source/install.rst b/cuda_bindings/docs/source/install.rst index 7f890365ea3..d77464ec91f 100644 --- a/cuda_bindings/docs/source/install.rst +++ b/cuda_bindings/docs/source/install.rst @@ -120,11 +120,14 @@ Requirements * CUDA Toolkit headers[^1] * CUDA Runtime static library[^2] +* A git clone of the repository that includes tags[^3] [^1]: User projects that ``cimport`` CUDA symbols in Cython must also use CUDA Toolkit (CTK) types as provided by the ``cuda.bindings`` major.minor version. This results in CTK headers becoming a transitive dependency of downstream projects through CUDA Python. [^2]: The CUDA Runtime static library (``libcudart_static.a`` on Linux, ``cudart_static.lib`` on Windows) is part of the CUDA Toolkit. If using conda packages, it is contained in the ``cuda-cudart-static`` package. +[^3]: The version is derived from git tags via ``setuptools-scm``, so the clone must include tags reaching back to at least the latest ``v*`` tag. Clone with ``git clone https://github.com/NVIDIA/cuda-python.git``; do not use ``--depth`` or ``--no-tags``, since a shallow clone builds without error but produces a bogus version such as ``0.1.dev1+g0d22cb444``. See `Cloning the repository `_ for details and recovery steps. + Source builds require that the provided CUDA headers are of the same major.minor version as the ``cuda.bindings`` you're trying to build. Despite this requirement, note that the minor version compatibility is still maintained. Use the ``CUDA_PATH`` (or ``CUDA_HOME``) environment variable to specify the location of your headers. If both are set, ``CUDA_PATH`` takes precedence. For example, if your headers are located in ``/usr/local/cuda/include``, then you should set ``CUDA_PATH`` with: .. code-block:: console diff --git a/cuda_core/docs/source/install.rst b/cuda_core/docs/source/install.rst index a49aab7c966..c048cfb2a2c 100644 --- a/cuda_core/docs/source/install.rst +++ b/cuda_core/docs/source/install.rst @@ -110,7 +110,7 @@ Development with uv .. code-block:: console - $ git clone https://github.com/NVIDIA/cuda-python + $ git clone https://github.com/NVIDIA/cuda-python.git $ cd cuda-python/cuda_core $ uv venv $ source .venv/bin/activate # On Windows: .venv\Scripts\activate @@ -132,7 +132,7 @@ From the repository root: .. code-block:: console - $ git clone https://github.com/NVIDIA/cuda-python + $ git clone https://github.com/NVIDIA/cuda-python.git $ cd cuda-python $ pixi run -e cu13 test-core @@ -151,8 +151,18 @@ Installing from Source .. code-block:: console - $ git clone https://github.com/NVIDIA/cuda-python + $ git clone https://github.com/NVIDIA/cuda-python.git $ cd cuda-python/cuda_core $ pip install . ``cuda-bindings`` 12.x or 13.x is a required dependency. + +.. note:: + + The version is derived from git tags via ``setuptools-scm``, so the clone + must include tags reaching back to at least the latest ``cuda-core-v*`` tag. + Do not use ``--depth`` or ``--no-tags``: a shallow clone builds without + error but produces a bogus version such as ``0.1.dev1+g0d22cb444``. See + `Cloning the repository + `_ + for details and recovery steps. diff --git a/cuda_pathfinder/docs/source/install.rst b/cuda_pathfinder/docs/source/install.rst index abc8fbb9d50..53f11ebbf18 100644 --- a/cuda_pathfinder/docs/source/install.rst +++ b/cuda_pathfinder/docs/source/install.rst @@ -59,7 +59,7 @@ Installing from Source .. code-block:: console - $ git clone https://github.com/NVIDIA/cuda-python + $ git clone https://github.com/NVIDIA/cuda-python.git $ cd cuda-python/cuda_pathfinder $ pip install . @@ -68,3 +68,13 @@ For an editable install (e.g. when developing ``cuda.pathfinder`` itself): .. code-block:: console $ pip install -v -e . + +.. note:: + + The version is derived from git tags via ``setuptools-scm``, so the clone + must include tags reaching back to at least the latest ``cuda-pathfinder-v*`` + tag. Do not use ``--depth`` or ``--no-tags``: a shallow clone builds without + error but produces a bogus version such as ``0.1.dev1+g0d22cb444``. See + `Cloning the repository + `_ + for details and recovery steps. From ad339abf96a8304be53408952119ce0313358a67 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Wed, 29 Jul 2026 15:41:57 -0400 Subject: [PATCH 09/50] Add cuda-core 1.1.1 release notes (#2452) --- cuda_core/docs/source/release/1.1.1-notes.rst | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 cuda_core/docs/source/release/1.1.1-notes.rst diff --git a/cuda_core/docs/source/release/1.1.1-notes.rst b/cuda_core/docs/source/release/1.1.1-notes.rst new file mode 100644 index 00000000000..66d74e3540b --- /dev/null +++ b/cuda_core/docs/source/release/1.1.1-notes.rst @@ -0,0 +1,59 @@ +.. SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +.. SPDX-License-Identifier: Apache-2.0 + +.. currentmodule:: cuda.core + +``cuda.core`` 1.1.1 Release Notes +================================= + + +New features +------------ + +- Added :meth:`ObjectCode.get_module` for interoperability with legacy + ``CUmodule``-based driver APIs. The method returns a context-dependent + ``CUmodule`` handle via ``cuLibraryGetModule``, bridging the newer + context-independent library API to existing code that expects a module. + (`#2339 `__) + +- ``cuda.core`` C++ headers are now included in source distributions and + installed wheels, making them available to downstream projects that extend + ``cuda.core`` at the C++ level. + (`#2236 `__) + + +Fixes and enhancements +---------------------- + +- This cuda-core patch release was issued to be compatible with cuda-bindings + 13.4.0b1. Version strings that include PEP 440 pre-release suffixes (e.g. + ``0b1``) are now parsed correctly; previously they caused an ``ImportError`` + on startup. + +- Graph nodes now properly retain per-node user-object attachments (kernel + argument buffers, host-callback functions and user data, and + memcpy/memset operands) for the full lifetime of the graph. + (`#2357 `__) + +- Graph user-object payload cleanup is now deferred to the main Python thread + via ``Py_AddPendingCall``, avoiding unsafe cross-thread Python object + destruction that could occur when CUDA invoked the destructor callback on an + internal driver thread. + (`#2371 `__) + +- The on-disk program cache directory is now created with owner-only + permissions (``0o700``) on POSIX systems, and those permissions are + re-asserted on each use. This prevents other local users from reading or + injecting cached device code regardless of the process ``umask``. + (`#2399 `__) + +- DLPack: a ``NULL`` deleter in a ``DLManagedTensorVersioned`` capsule is now + handled correctly per the DLPack specification; previously it would cause a + crash. + (`#2427 `__) + +- Corrected NumPy version guards for writing into DLPack host arrays. The + minimum required NumPy version for such writes is now correctly enforced as + 2.2.5+; earlier NumPy versions return a read-only buffer + (``numpy GH#28632``) and would error rather than skip. + (`#2238 `__) From 51d402c9cd472c85d92c892318a9a01a3b9dff47 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Wed, 29 Jul 2026 18:50:38 -0400 Subject: [PATCH 10/50] Add griffe to CI (#2300) --- .github/actions/griffe-api-check/action.yml | 44 +++++++++++ .github/workflows/ci.yml | 85 +++++++++++++++++++++ 2 files changed, 129 insertions(+) create mode 100644 .github/actions/griffe-api-check/action.yml diff --git a/.github/actions/griffe-api-check/action.yml b/.github/actions/griffe-api-check/action.yml new file mode 100644 index 00000000000..6c090ddeb43 --- /dev/null +++ b/.github/actions/griffe-api-check/action.yml @@ -0,0 +1,44 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# SPDX-License-Identifier: Apache-2.0 + +name: griffe API check + +description: >- + Check a package's public API (as defined by `__all__`) for changes using + griffe. + +inputs: + package-name: + description: "Importable package name to check, e.g. cuda.core" + required: true + package-dir: + description: "Directory to search for the package sources, e.g. cuda_core" + required: true + merge-base: + description: >- + Git ref/sha to compare the current code against, typically the PR's + merge-base with its target branch. + required: true + +runs: + using: composite + steps: + - name: Install uv + uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0 + with: + enable-cache: false + + - name: Check API + shell: bash --noprofile --norc -euo pipefail {0} + env: + PACKAGE_NAME: ${{ inputs.package-name }} + PACKAGE_DIR: ${{ inputs.package-dir }} + MERGE_BASE: ${{ inputs.merge-base }} + run: | + uvx griffe check "$PACKAGE_NAME" \ + --search "$PACKAGE_DIR" \ + --find-stubs-packages \ + --against "$MERGE_BASE" \ + --format github \ + 2>&1 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fe43b52d01a..442476ba05e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -103,6 +103,7 @@ jobs: test_bindings: ${{ steps.compose.outputs.test_bindings }} test_core: ${{ steps.compose.outputs.test_core }} test_pathfinder: ${{ steps.compose.outputs.test_pathfinder }} + pr_merge_base: ${{ steps.filter.outputs.merge_base }} steps: - name: Checkout repository uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 @@ -156,6 +157,7 @@ jobs: echo "python_meta=$(has_match '^cuda_python/')" echo "test_helpers=$(has_match '^cuda_python_test_helpers/')" echo "shared=$(has_match '^(\.github/|ci/|scripts/|toolshed/|conftest\.py$|pyproject\.toml$|pixi\.(toml|lock)$|pytest\.ini$|ruff\.toml$)')" + echo "merge_base=${base}" } >> "$GITHUB_OUTPUT" - name: Compose gating outputs @@ -228,6 +230,89 @@ jobs: echo "test_pathfinder=${test_pathfinder}" } >> "$GITHUB_OUTPUT" + api-check-core-vs-release: + name: API check (cuda_core vs. latest release) + if: >- + ${{ !fromJSON(needs.should-skip.outputs.skip) && + fromJSON(needs.detect-changes.outputs.core) }} + runs-on: ubuntu-latest + needs: + - should-skip + - detect-changes + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + fetch-depth: 1 + filter: blob:none + + - name: Find latest release tag + id: latest-tag + shell: bash --noprofile --norc -euo pipefail {0} + env: + GH_TOKEN: ${{ github.token }} + run: | + # --paginate fetches all pages; jq outputs one name per line per page; + # head -1 takes the first (newest) match since GitHub returns tags + # newest-first. Fails hard if no cuda-core-v* tag is found. + tag="$(gh api "repos/$GITHUB_REPOSITORY/tags" --paginate \ + --jq '.[] | select(.name | startswith("cuda-core-v")) | .name' \ + | head -1)" + if [[ -z "${tag}" ]]; then + echo "::error::No cuda-core-v* tag found in the repository." >&2 + exit 1 + fi + echo "tag=${tag}" >> "$GITHUB_OUTPUT" + + - name: Fetch release tag + shell: bash --noprofile --norc -euo pipefail {0} + run: | + git fetch --depth=1 --filter=blob:none origin \ + "refs/tags/${{ steps.latest-tag.outputs.tag }}:refs/tags/${{ steps.latest-tag.outputs.tag }}" + + - name: Check cuda_core public API + id: griffe + uses: ./.github/actions/griffe-api-check + with: + package-name: cuda.core + package-dir: cuda_core + merge-base: ${{ steps.latest-tag.outputs.tag }} + + api-check-core-vs-base: + name: API check (cuda_core vs. merge base) + if: >- + ${{ startsWith(github.ref_name, 'pull-request/') && + !fromJSON(needs.should-skip.outputs.skip) && + fromJSON(needs.detect-changes.outputs.core) }} + runs-on: ubuntu-latest + needs: + - should-skip + - detect-changes + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + fetch-depth: 1 + filter: blob:none + + - name: Fetch merge base commit + shell: bash --noprofile --norc -euo pipefail {0} + run: | + git fetch --depth=1 --filter=blob:none origin \ + "${{ needs.detect-changes.outputs.pr_merge_base }}" + + - name: Check cuda_core public API + id: griffe + uses: ./.github/actions/griffe-api-check + with: + package-name: cuda.core + package-dir: cuda_core + merge-base: ${{ needs.detect-changes.outputs.pr_merge_base }} + # NOTE: Build jobs are intentionally split by platform rather than using a single # matrix. This allows each test job to depend only on its corresponding build, # so faster platforms can proceed through build & test without waiting for slower From 608cc5fbb053fdc862ae14cda18d09c9f0cae8cc Mon Sep 17 00:00:00 2001 From: Andy Jost Date: Thu, 30 Jul 2026 10:18:16 -0700 Subject: [PATCH 11/50] cuda.core: add graph definition node updates (#2395) * feat(cuda.core): add event record node updates Use the generic node setter with failure-atomic attachment replacement, establishing the shared path for definition-level parameter mutation. * test(cuda.core): remove unused graph update import * feat(cuda.core): add event wait and host node updates Extend definition-level mutation to event waits and both Python and ctypes host callbacks while preserving old executable state and attachment ownership. * feat(cuda.core): require CUDA 12.2 for node updates Report unsupported driver or binding versions before preparing mutation attachments or calling the generic node setter. * feat(cuda.core): add memset node updates Allow partial memset parameter replacement while preserving graph-owned destination lifetimes and previously instantiated graph behavior. * feat(cuda.core): add memcpy node updates Support partial copy parameter replacement while preserving independent source and destination ownership across graph instantiations. * feat(cuda.core): add kernel node updates Support independent launch configuration and argument replacement while requiring explicit arguments when changing kernels. * feat(cuda.core): add child graph node updates Replace embedded child hierarchies while preserving attachment metadata, invalidating stale views, and keeping existing executables independent. * docs(cuda.core): document graph node updates Describe supported mutation methods, CUDA 12.2 requirements, and executable graph behavior in the API and release notes. * fix(cuda.core): avoid cross-extension deleter symbol Use type-erased shared ownership for prepared child updates so extension loading does not depend on a hidden C++ deleter symbol. * fix(cuda.core): align prepared child update stub Reflect shared ownership for the opaque child update transaction in the generated stub. * api(cuda.core): make partial node updates keyword-only Make memcpy and memset mutation calls explicit and unambiguous before the public API freezes. * fix(cuda.core): harden graph node updates Preserve memory-node contexts, reject unsupported node forms, and fail clearly when child graph metadata cannot be updated. * fix(cuda.core): support older bindings in node updates Resolve the CUDA 13.2 graph parameter getter dynamically so CUDA 12 binding builds remain compilable. * fix(cuda.core): harden memory node updates Clarify parameter handling and cover host/device memory transitions while exposing context-sensitive test teardown for follow-up. * test(cuda.core): reject updates to destroyed nodes Cover the public invalid-node state to ensure parameter updates fail cleanly without restoring graph membership. --- cuda_core/cuda/core/_cpp/resource_handles.cpp | 246 ++++-- cuda_core/cuda/core/_cpp/resource_handles.hpp | 21 + cuda_core/cuda/core/_resource_handles.pxd | 12 + cuda_core/cuda/core/_resource_handles.pyi | 3 +- cuda_core/cuda/core/_resource_handles.pyx | 6 + cuda_core/cuda/core/graph/_graph_node.pxd | 16 +- cuda_core/cuda/core/graph/_graph_node.pyi | 3 + cuda_core/cuda/core/graph/_graph_node.pyx | 76 +- cuda_core/cuda/core/graph/_host_callback.pyx | 3 + cuda_core/cuda/core/graph/_subclasses.pyi | 80 ++ cuda_core/cuda/core/graph/_subclasses.pyx | 530 ++++++++++++- cuda_core/docs/source/api.rst | 16 + cuda_core/docs/source/release/1.2.0-notes.rst | 7 + .../graph/test_graph_definition_lifetime.py | 93 +++ .../tests/graph/test_graph_node_update.py | 741 ++++++++++++++++++ cuda_core/tests/helpers/graph_kernels.py | 11 +- cuda_core/tests/test_green_context.py | 36 +- 17 files changed, 1814 insertions(+), 86 deletions(-) create mode 100644 cuda_core/tests/graph/test_graph_node_update.py diff --git a/cuda_core/cuda/core/_cpp/resource_handles.cpp b/cuda_core/cuda/core/_cpp/resource_handles.cpp index b3d2e3fe373..2102d36f22f 100644 --- a/cuda_core/cuda/core/_cpp/resource_handles.cpp +++ b/cuda_core/cuda/core/_cpp/resource_handles.cpp @@ -361,6 +361,15 @@ class HandleRegistry { map_.erase(key); } + void register_handles(const std::vector& handles) { + std::lock_guard lock(mutex_); + for (const Handle& h : handles) { + if (h) { + map_[*h] = h; + } + } + } + Handle lookup(const Key& key) { std::lock_guard lock(mutex_); auto it = map_.find(key); @@ -1341,7 +1350,8 @@ struct GraphHierarchy { }; // See REGISTRY_DESIGN.md (Level 1: Driver Handle -> Resource Handle) -static HandleRegistry graph_registry; +using GraphRegistry = HandleRegistry; +static GraphRegistry graph_registry; // Immutable resource owners for one version of a graph node's parameters. // Inheriting DeferredCleanupItem lets CUDA's user-object destructor enqueue @@ -1404,52 +1414,71 @@ CUresult rekey_attachments( return CUDA_SUCCESS; } -// Recursively copy and rekey attachments for a cloned graph hierarchy. -// The caller must release the GIL before calling this function. -CUresult copy_attachments( +struct StagedGraphMetadata { + const GraphBox* source; + GraphBox* clone; + GraphAttachmentMap* attachments; +}; +using StagedGraphMetadataList = std::vector; + +// Copy a source hierarchy into detached metadata before CUDA mutation. +void stage_graph_metadata( const GraphBox& source, GraphBox& clone, GraphAttachmentMap& attachments, - std::list& subgraphs) { - if (!p_cuGraphNodeFindInClone || !p_cuGraphChildGraphNodeGetGraph) { - return CUDA_ERROR_NOT_SUPPORTED; - } - + std::list& subgraphs, + StagedGraphMetadataList& staged) { attachments = source.attachments; - CUresult status = rekey_attachments(attachments, clone.resource); - if (status != CUDA_SUCCESS) { - return status; - } + staged.push_back({&source, &clone, &attachments}); for (const GraphBox& source_child : source.hierarchy->graphs) { if (source_child.parent != &source || !source_child.resource) { continue; } - - CUgraphNode cloned_owner = nullptr; - status = p_cuGraphNodeFindInClone( - &cloned_owner, source_child.owner_node, clone.resource); - if (status != CUDA_SUCCESS) { - return status; - } - - CUgraph cloned_graph = nullptr; - status = p_cuGraphChildGraphNodeGetGraph( - cloned_owner, &cloned_graph); - if (status != CUDA_SUCCESS) { - return status; - } - GraphBox& cloned_child = subgraphs.emplace_back( - cloned_graph, + nullptr, clone.hierarchy, &clone, - cloned_owner); - status = copy_attachments( + nullptr); + stage_graph_metadata( source_child, cloned_child, cloned_child.attachments, - subgraphs); + subgraphs, + staged); + } +} + +// Bind staged metadata to a CUDA-cloned hierarchy. The root clone resource +// must be populated before entry. The caller must release the GIL. +CUresult rekey_graph_metadata( + StagedGraphMetadataList& staged) { + if (!p_cuGraphNodeFindInClone || !p_cuGraphChildGraphNodeGetGraph) { + return CUDA_ERROR_NOT_SUPPORTED; + } + + CUresult status; + for (size_t i = 0; i < staged.size(); ++i) { + const GraphBox& source = *staged[i].source; + GraphBox& clone = *staged[i].clone; + if (i != 0) { + CUgraphNode cloned_owner = nullptr; + status = p_cuGraphNodeFindInClone( + &cloned_owner, + source.owner_node, + clone.parent->resource); + if (status == CUDA_SUCCESS) { + status = p_cuGraphChildGraphNodeGetGraph( + cloned_owner, &clone.resource); + } + if (status != CUDA_SUCCESS) { + return status; + } + clone.owner_node = cloned_owner; + } + + status = rekey_attachments( + *staged[i].attachments, clone.resource); if (status != CUDA_SUCCESS) { return status; } @@ -1497,6 +1526,29 @@ void rollback_prepared_attachment( delete state; } +// Detached metadata for a replacement embedded graph hierarchy. Preparation +// copies every attachment map and allocates every GraphBox before CUDA destroys +// the old embedded graph. Commit only rekeys and publishes it. +struct PreparedChildGraphUpdateState { + GraphHandle h_parent; + GraphHandle h_source; + GraphBox* old_root = nullptr; + CUgraphNode owner_node = nullptr; + std::list replacement; + StagedGraphMetadataList staged; + std::vector handles; + + PreparedChildGraphUpdateState( + GraphHandle h_parent_, + GraphHandle h_source_, + GraphBox* old_root_, + CUgraphNode owner_node_) + : h_parent(std::move(h_parent_)), + h_source(std::move(h_source_)), + old_root(old_root_), + owner_node(owner_node_) {} +}; + GraphHandle create_graph_handle(CUgraph graph) { if (!graph) { return {}; @@ -1543,15 +1595,112 @@ GraphHandle create_child_graph_handle( child_graph, hierarchy, parent, owner_node); GraphHandle h_child(h_parent, &child.resource); - try { - graph_registry.register_handle(child_graph, h_child); - } catch (...) { - hierarchy->graphs.pop_back(); - throw; - } + graph_registry.register_handle(child_graph, h_child); return h_child; } +CUresult graph_prepare_child_graph_update( + const GraphHandle& h_parent, + const GraphHandle& h_old_child, + CUgraphNode owner_node, + const GraphHandle& h_source, + PreparedChildGraphUpdate* out_prepared) { + if (!h_parent || !h_old_child || !owner_node || + !h_source || !out_prepared) { + return CUDA_ERROR_INVALID_VALUE; + } + out_prepared->reset(); + + GraphBox* parent = get_box(h_parent); + GraphBox* old_root = get_box(h_old_child); + GraphBox* source = get_box(h_source); + // A source from the destination hierarchy can include the old embedded + // subtree whose raw node keys CUDA destroys during replacement. + if (!parent->resource || !old_root->resource || !source->resource || + old_root->parent != parent || + old_root->owner_node != owner_node || + source->hierarchy == parent->hierarchy) { + return CUDA_ERROR_INVALID_VALUE; + } + + PreparedChildGraphUpdate prepared = + std::make_shared( + h_parent, h_source, old_root, owner_node); + + GraphBox& replacement_root = + prepared->replacement.emplace_back( + nullptr, parent->hierarchy, parent, owner_node); + stage_graph_metadata( + *source, + replacement_root, + replacement_root.attachments, + prepared->replacement, + prepared->staged); + + const size_t graph_count = prepared->staged.size(); + prepared->handles.reserve(graph_count); + for (const StagedGraphMetadata& graph : prepared->staged) { + prepared->handles.emplace_back( + h_parent, &graph.clone->resource); + } + + *out_prepared = std::move(prepared); + return CUDA_SUCCESS; +} + +void publish_child_graph_update( + PreparedChildGraphUpdateState& state, + GraphHandle* out_child) { + GraphBox* parent = get_box(state.h_parent); + parent->hierarchy->graphs.splice( + parent->hierarchy->graphs.end(), state.replacement); + *out_child = state.handles.front(); + graph_registry.register_handles(state.handles); +} + +CUresult graph_commit_child_graph_update( + PreparedChildGraphUpdate& prepared, + GraphHandle* out_child) { + if (!prepared || !out_child) { + return CUDA_ERROR_INVALID_VALUE; + } + out_child->reset(); + + PreparedChildGraphUpdateState& state = *prepared; + GraphBox* parent = get_box(state.h_parent); + if (!parent->resource || !state.old_root->resource) { + prepared.reset(); + return CUDA_ERROR_INVALID_VALUE; + } + + CUresult status = CUDA_ERROR_NOT_SUPPORTED; + CUgraph cloned_root = nullptr; + if (p_cuGraphChildGraphNodeGetGraph) { + GILReleaseGuard gil; + status = p_cuGraphChildGraphNodeGetGraph( + state.owner_node, &cloned_root); + if (status == CUDA_SUCCESS) { + state.staged.front().clone->resource = cloned_root; + status = rekey_graph_metadata(state.staged); + } + } + + // CUDA has already destroyed the old embedded graph. No replacement + // metadata is visible yet, so this selects only the old generation. + invalidate_child_graph_state( + state.h_parent, state.owner_node); + + if (status != CUDA_SUCCESS) { + prepared.reset(); + throw std::runtime_error( + "failed to update graph metadata after child graph replacement"); + } + + publish_child_graph_update(state, out_child); + prepared.reset(); + return status; +} + CUresult graph_get_attachment( const GraphHandle& h_graph, CUgraphNode node, OpaqueHandle* owner0, OpaqueHandle* owner1) { @@ -1727,13 +1876,22 @@ CUresult graph_clone_attachments( // Build and rekey the clone metadata off-hierarchy so a CUDA mapping error // cannot partially publish it. - GraphAttachmentMap attachments = source->attachments; + GraphAttachmentMap attachments; std::list subgraphs; + StagedGraphMetadataList staged; + stage_graph_metadata( + *source, *clone, attachments, subgraphs, staged); + + std::vector handles; + handles.reserve(subgraphs.size()); + for (GraphBox& graph : subgraphs) { + handles.emplace_back(h_clone, &graph.resource); + } + CUresult status; { GILReleaseGuard gil; - status = copy_attachments( - *source, *clone, attachments, subgraphs); + status = rekey_graph_metadata(staged); } if (status != CUDA_SUCCESS) { return status; @@ -1744,13 +1902,9 @@ CUresult graph_clone_attachments( return CUDA_SUCCESS; } - auto first = subgraphs.begin(); clone->hierarchy->graphs.splice( clone->hierarchy->graphs.end(), subgraphs); - for (auto it = first; it != clone->hierarchy->graphs.end(); ++it) { - GraphHandle h_graph(h_clone, &it->resource); - graph_registry.register_handle(it->resource, h_graph); - } + graph_registry.register_handles(handles); return CUDA_SUCCESS; } diff --git a/cuda_core/cuda/core/_cpp/resource_handles.hpp b/cuda_core/cuda/core/_cpp/resource_handles.hpp index 3a9d2d75cff..60a9f3c53a9 100644 --- a/cuda_core/cuda/core/_cpp/resource_handles.hpp +++ b/cuda_core/cuda/core/_cpp/resource_handles.hpp @@ -516,6 +516,12 @@ struct PreparedAttachmentDeleter { using PreparedAttachment = std::unique_ptr; +struct PreparedChildGraphUpdateState; +// Opaque unpublished hierarchy transaction; releasing it discards staged +// metadata unless graph_commit_child_graph_update publishes the replacement. +using PreparedChildGraphUpdate = + std::shared_ptr; + // Copy requested owners from node's current attachment. Pass nullptr to ignore // either owner; a missing attachment produces empty handles. CUresult graph_get_attachment( @@ -543,6 +549,21 @@ CUresult graph_clone_attachments( const GraphHandle& h_clone, const GraphHandle& h_source); +// Stage a complete metadata replacement before CUDA replaces an embedded +// graph. Dropping the prepared state leaves the current hierarchy unchanged. +CUresult graph_prepare_child_graph_update( + const GraphHandle& h_parent, + const GraphHandle& h_old_child, + CUgraphNode owner_node, + const GraphHandle& h_source, + PreparedChildGraphUpdate* out_prepared); + +// Rekey staged metadata to CUDA's replacement clone, retire the old embedded +// hierarchy, and publish the replacement handle. +CUresult graph_commit_child_graph_update( + PreparedChildGraphUpdate& prepared, + GraphHandle* out_child); + // Invalidate cuda.core state for child graphs CUDA destroyed with owner_node. void invalidate_child_graph_state( const GraphHandle& h_parent, diff --git a/cuda_core/cuda/core/_resource_handles.pxd b/cuda_core/cuda/core/_resource_handles.pxd index 2f481fee4f8..b0ae65d1666 100644 --- a/cuda_core/cuda/core/_resource_handles.pxd +++ b/cuda_core/cuda/core/_resource_handles.pxd @@ -71,6 +71,12 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": PreparedAttachmentState, PreparedAttachmentDeleter ] PreparedAttachment + cppclass PreparedChildGraphUpdateState: + pass + ctypedef shared_ptr[ + PreparedChildGraphUpdateState + ] PreparedChildGraphUpdate + # as_cu() - extract the raw CUDA handle (inline C++) cydriver.CUcontext as_cu(ContextHandle h) noexcept nogil cydriver.CUgreenCtx as_cu(GreenCtxHandle h) noexcept nogil @@ -253,6 +259,12 @@ cdef cydriver.CUresult graph_commit_attachment( PreparedAttachment& prepared, cydriver.CUgraphNode node) except+ cdef cydriver.CUresult graph_clone_attachments( const GraphHandle& h_clone, const GraphHandle& h_source) except+ +cdef cydriver.CUresult graph_prepare_child_graph_update( + const GraphHandle& h_parent, const GraphHandle& h_old_child, + cydriver.CUgraphNode owner_node, const GraphHandle& h_source, + PreparedChildGraphUpdate* out_prepared) except+ +cdef cydriver.CUresult graph_commit_child_graph_update( + PreparedChildGraphUpdate& prepared, GraphHandle* out_child) except+ cdef void invalidate_child_graph_state( const GraphHandle& h_parent, cydriver.CUgraphNode owner_node) noexcept diff --git a/cuda_core/cuda/core/_resource_handles.pyi b/cuda_core/cuda/core/_resource_handles.pyi index f11f6f08e00..c1bbb3983c9 100644 --- a/cuda_core/cuda/core/_resource_handles.pyi +++ b/cuda_core/cuda/core/_resource_handles.pyi @@ -26,4 +26,5 @@ MipmappedArrayHandle = shared_ptr TexObjectHandle = shared_ptr SurfObjectHandle = shared_ptr OpaqueHandle = shared_ptr -PreparedAttachment = unique_ptr \ No newline at end of file +PreparedAttachment = unique_ptr +PreparedChildGraphUpdate = shared_ptr \ No newline at end of file diff --git a/cuda_core/cuda/core/_resource_handles.pyx b/cuda_core/cuda/core/_resource_handles.pyx index f6fb6ac4e20..a1b0d912a71 100644 --- a/cuda_core/cuda/core/_resource_handles.pyx +++ b/cuda_core/cuda/core/_resource_handles.pyx @@ -167,6 +167,12 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": PreparedAttachment& prepared, cydriver.CUgraphNode node) except+ cydriver.CUresult graph_clone_attachments "cuda_core::graph_clone_attachments" ( const GraphHandle& h_clone, const GraphHandle& h_source) except+ + cydriver.CUresult graph_prepare_child_graph_update "cuda_core::graph_prepare_child_graph_update" ( + const GraphHandle& h_parent, const GraphHandle& h_old_child, + cydriver.CUgraphNode owner_node, const GraphHandle& h_source, + PreparedChildGraphUpdate* out_prepared) except+ + cydriver.CUresult graph_commit_child_graph_update "cuda_core::graph_commit_child_graph_update" ( + PreparedChildGraphUpdate& prepared, GraphHandle* out_child) except+ void invalidate_child_graph_state "cuda_core::invalidate_child_graph_state" ( const GraphHandle& h_parent, cydriver.CUgraphNode owner_node) noexcept diff --git a/cuda_core/cuda/core/graph/_graph_node.pxd b/cuda_core/cuda/core/graph/_graph_node.pxd index 0a87b70ad62..2ad4851a54c 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pxd +++ b/cuda_core/cuda/core/graph/_graph_node.pxd @@ -2,8 +2,10 @@ # # SPDX-License-Identifier: Apache-2.0 +from libc.stddef cimport size_t + from cuda.bindings cimport cydriver -from cuda.core._resource_handles cimport GraphHandle, GraphNodeHandle +from cuda.core._resource_handles cimport GraphHandle, GraphNodeHandle, OpaqueHandle cdef class GraphNode: @@ -13,3 +15,15 @@ cdef class GraphNode: @staticmethod cdef GraphNode _create(GraphHandle h_graph, cydriver.CUgraphNode node) + + +cdef OpaqueHandle _resolve_memcpy_operand( + object operand, object owner, str side, cydriver.CUdeviceptr* out_ptr) except * + +cdef cydriver.CUmemorytype _get_memcpy_memory_type( + cydriver.CUdeviceptr ptr) except * + +cdef void _init_memcpy_params( + cydriver.CUdeviceptr dst, cydriver.CUdeviceptr src, size_t size, + cydriver.CUDA_MEMCPY3D* params, cydriver.CUmemorytype* dst_type, + cydriver.CUmemorytype* src_type) except * diff --git a/cuda_core/cuda/core/graph/_graph_node.pyi b/cuda_core/cuda/core/graph/_graph_node.pyi index 23bcbf191a3..ab503183f63 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyi +++ b/cuda_core/cuda/core/graph/_graph_node.pyi @@ -94,6 +94,9 @@ class GraphNode: def launch(self, config: LaunchConfig, kernel: Kernel, *args) -> KernelNode: """Add a kernel launch node depending on this node. + Clustered and cooperative launch configurations are not currently + supported for graph kernel nodes. + .. warning:: Use caution when a retained kernel argument directly or indirectly diff --git a/cuda_core/cuda/core/graph/_graph_node.pyx b/cuda_core/cuda/core/graph/_graph_node.pyx index 41ab9728b80..38bc6f955e6 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyx +++ b/cuda_core/cuda/core/graph/_graph_node.pyx @@ -207,6 +207,9 @@ cdef class GraphNode: def launch(self, config: LaunchConfig, kernel: Kernel, *args) -> KernelNode: """Add a kernel launch node depending on this node. + Clustered and cooperative launch configurations are not currently + supported for graph kernel nodes. + .. warning:: Use caution when a retained kernel argument directly or indirectly @@ -720,6 +723,10 @@ cdef inline KernelNode GN_launch(GraphNode self, LaunchConfig conf, Kernel ker, cdef OpaqueHandle args_owner cdef PreparedAttachment prepared + if conf.cluster is not None or conf.is_cooperative: + raise NotImplementedError( + "clustered or cooperative graph kernel nodes are not supported") + if pred_node != NULL: deps = &pred_node num_deps = 1 @@ -890,7 +897,8 @@ cdef inline OpaqueHandle _buffer_attachment_owner(Buffer buf, str label): cdef inline OpaqueHandle _resolve_memcpy_operand( - object operand, object owner, str side, cydriver.CUdeviceptr* out_ptr): + object operand, object owner, str side, + cydriver.CUdeviceptr* out_ptr) except *: """Resolve an operand to a pointer and optional attachment owner. ``operand`` is a :class:`Buffer` or a raw integer address; its device @@ -970,46 +978,52 @@ cdef inline MemsetNode GN_memset( val, elem_size, width, height, pitch)) -cdef inline MemcpyNode GN_memcpy( - GraphNode self, cydriver.CUdeviceptr c_dst, OpaqueHandle dst_owner, - cydriver.CUdeviceptr c_src, OpaqueHandle src_owner, size_t size): - cdef unsigned int dst_mem_type = cydriver.CU_MEMORYTYPE_DEVICE - cdef unsigned int src_mem_type = cydriver.CU_MEMORYTYPE_DEVICE +cdef cydriver.CUmemorytype _get_memcpy_memory_type( + cydriver.CUdeviceptr ptr) except *: + cdef unsigned int memory_type = cydriver.CU_MEMORYTYPE_DEVICE cdef cydriver.CUresult ret with nogil: ret = cydriver.cuPointerGetAttribute( - &dst_mem_type, + &memory_type, cydriver.CU_POINTER_ATTRIBUTE_MEMORY_TYPE, - c_dst) - if ret != cydriver.CUDA_SUCCESS and ret != cydriver.CUDA_ERROR_INVALID_VALUE: - HANDLE_RETURN(ret) - ret = cydriver.cuPointerGetAttribute( - &src_mem_type, - cydriver.CU_POINTER_ATTRIBUTE_MEMORY_TYPE, - c_src) - if ret != cydriver.CUDA_SUCCESS and ret != cydriver.CUDA_ERROR_INVALID_VALUE: - HANDLE_RETURN(ret) - - cdef cydriver.CUmemorytype c_dst_type = dst_mem_type - cdef cydriver.CUmemorytype c_src_type = src_mem_type - - cdef cydriver.CUDA_MEMCPY3D params - c_memset(¶ms, 0, sizeof(params)) - - params.srcMemoryType = c_src_type - params.dstMemoryType = c_dst_type - if c_src_type == cydriver.CU_MEMORYTYPE_HOST: - params.srcHost = c_src + ptr) + if ret != cydriver.CUDA_SUCCESS and ret != cydriver.CUDA_ERROR_INVALID_VALUE: + HANDLE_RETURN(ret) + return memory_type + + +cdef void _init_memcpy_params( + cydriver.CUdeviceptr dst, cydriver.CUdeviceptr src, size_t size, + cydriver.CUDA_MEMCPY3D* params, cydriver.CUmemorytype* dst_type, + cydriver.CUmemorytype* src_type) except *: + dst_type[0] = _get_memcpy_memory_type(dst) + src_type[0] = _get_memcpy_memory_type(src) + + c_memset(params, 0, sizeof(params[0])) + params.srcMemoryType = src_type[0] + params.dstMemoryType = dst_type[0] + if src_type[0] == cydriver.CU_MEMORYTYPE_HOST: + params.srcHost = src else: - params.srcDevice = c_src - if c_dst_type == cydriver.CU_MEMORYTYPE_HOST: - params.dstHost = c_dst + params.srcDevice = src + if dst_type[0] == cydriver.CU_MEMORYTYPE_HOST: + params.dstHost = dst else: - params.dstDevice = c_dst + params.dstDevice = dst params.WidthInBytes = size params.Height = 1 params.Depth = 1 + +cdef inline MemcpyNode GN_memcpy( + GraphNode self, cydriver.CUdeviceptr c_dst, OpaqueHandle dst_owner, + cydriver.CUdeviceptr c_src, OpaqueHandle src_owner, size_t size): + cdef cydriver.CUDA_MEMCPY3D params + cdef cydriver.CUmemorytype c_dst_type + cdef cydriver.CUmemorytype c_src_type + _init_memcpy_params( + c_dst, c_src, size, ¶ms, &c_dst_type, &c_src_type) + cdef cydriver.CUgraphNode new_node = NULL cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) cdef cydriver.CUgraphNode pred_node = as_cu(self._h_node) diff --git a/cuda_core/cuda/core/graph/_host_callback.pyx b/cuda_core/cuda/core/graph/_host_callback.pyx index 27f251abeae..5fd71f8653f 100644 --- a/cuda_core/cuda/core/graph/_host_callback.pyx +++ b/cuda_core/cuda/core/graph/_host_callback.pyx @@ -54,6 +54,9 @@ cdef void _resolve_host_callback( else: out_user_data[0] = NULL else: + if not callable(fn): + raise TypeError( + f"callback must be callable, got {type(fn).__name__}") if user_data is not None: raise ValueError( "user_data is only supported with ctypes function pointers") diff --git a/cuda_core/cuda/core/graph/_subclasses.pyi b/cuda_core/cuda/core/graph/_subclasses.pyi index 345e6417c4d..2e6d4dd9529 100644 --- a/cuda_core/cuda/core/graph/_subclasses.pyi +++ b/cuda_core/cuda/core/graph/_subclasses.pyi @@ -5,6 +5,7 @@ from __future__ import annotations from cuda.core._event import Event from cuda.core._launch_config import LaunchConfig +from cuda.core._memory._buffer import Buffer from cuda.core._module import Kernel from cuda.core.graph._graph_definition import GraphCondition, GraphDefinition from cuda.core.graph._graph_node import GraphNode @@ -37,6 +38,21 @@ class KernelNode(GraphNode): def __repr__(self) -> str: ... + def update(self, *, config: LaunchConfig | None=None, kernel: Kernel | None=None, args=None) -> None: + """Replace selected kernel launch parameters. + + Omitted parameters preserve their current values. Changing ``kernel`` + requires ``args``, including ``args=()`` for a no-argument kernel. + Clustered and cooperative kernel nodes are not supported. + + .. warning:: + + Use caution when a retained kernel argument directly or indirectly + owns a graph. Any reference cycle involving the argument and a + graph that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + @property def grid(self) -> tuple[int, int, int]: """Grid dimensions as a 3-tuple (gridDimX, gridDimY, gridDimZ).""" @@ -139,6 +155,24 @@ class MemsetNode(GraphNode): def __repr__(self) -> str: ... + def update(self, *, dst: Buffer | int | None=None, value=None, width: int | None=None, height: int | None=None, pitch: int | None=None, dst_owner=None) -> None: + """Replace selected memset parameters. + + Omitted parameters preserve their current values. ``dst_owner`` may + only accompany a raw-address ``dst``. + + With CUDA 12.2 through 13.1, the node's intended CUDA context must be + current when this method is called. CUDA driver and ``cuda.bindings`` + versions 13.2 and newer preserve the recorded context automatically. + + .. warning:: + + Use caution when a retained operand owner directly or indirectly + owns a graph. Any reference cycle involving the owner and a graph + that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + @property def dptr(self) -> int: """The destination device pointer.""" @@ -179,6 +213,26 @@ class MemcpyNode(GraphNode): def __repr__(self) -> str: ... + def update(self, *, dst: Buffer | int | None=None, src: Buffer | int | None=None, size: int | None=None, dst_owner=None, src_owner=None) -> None: + """Replace selected memcpy parameters. + + Omitted parameters preserve their current values. ``dst_owner`` and + ``src_owner`` may only accompany their corresponding raw addresses. + Multidimensional, pitched, offset, and array-backed memcpy nodes are + not supported. + + With CUDA 12.2 through 13.1, the node's intended CUDA context must be + current when this method is called. CUDA driver and ``cuda.bindings`` + versions 13.2 and newer preserve the recorded context automatically. + + .. warning:: + + Use caution when a retained operand owner directly or indirectly + owns a graph. Any reference cycle involving the owner and a graph + that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + @property def dst(self) -> int: """The destination pointer.""" @@ -203,6 +257,12 @@ class ChildGraphNode(GraphNode): def __repr__(self) -> str: ... + def update(self, child: GraphDefinition) -> None: + """Replace the embedded graph with a clone of ``child``. + + ``child`` must belong to an independent graph hierarchy. + """ + @property def child_graph(self) -> GraphDefinition: """The embedded graph definition (non-owning wrapper).""" @@ -219,6 +279,9 @@ class EventRecordNode(GraphNode): def __repr__(self) -> str: ... + def update(self, event: Event) -> None: + """Replace the event recorded by this node.""" + @property def event(self) -> Event: """The event being recorded.""" @@ -235,6 +298,9 @@ class EventWaitNode(GraphNode): def __repr__(self) -> str: ... + def update(self, event: Event) -> None: + """Replace the event waited on by this node.""" + @property def event(self) -> Event: """The event being waited on.""" @@ -251,6 +317,20 @@ class HostCallbackNode(GraphNode): def __repr__(self) -> str: ... + def update(self, fn, *, user_data=None) -> None: + """Replace the callback and user-data binding for this node. + + .. warning:: + + Callbacks must not call CUDA API functions. Doing so may + deadlock or corrupt driver state. + + Use caution when a Python callback retains an object that owns a + graph. Any reference cycle involving the callback and a graph that + retains it cannot be broken by Python's cyclic garbage collector. + Use a weak reference to break such cycles. + """ + @property def callback(self): """The Python callable, or None for ctypes function pointer callbacks.""" diff --git a/cuda_core/cuda/core/graph/_subclasses.pyx b/cuda_core/cuda/core/graph/_subclasses.pyx index 2fa08e2a6a1..04b2cc908dc 100644 --- a/cuda_core/cuda/core/graph/_subclasses.pyx +++ b/cuda_core/cuda/core/graph/_subclasses.pyx @@ -8,29 +8,49 @@ from __future__ import annotations from libc.stddef cimport size_t from libc.stdint cimport uintptr_t +from libc.string cimport memset as c_memset from cuda.bindings cimport cydriver from cuda.core._event cimport Event +from cuda.core._kernel_arg_handler cimport ParamHolder from cuda.core._launch_config cimport LaunchConfig +from cuda.core._memory._buffer cimport Buffer from cuda.core._module cimport Kernel from cuda.core.graph._graph_definition cimport GraphCondition, GraphDefinition -from cuda.core.graph._graph_node cimport GraphNode +from cuda.core.graph._graph_node cimport ( + GraphNode, + _get_memcpy_memory_type, + _resolve_memcpy_operand, +) from cuda.core._resource_handles cimport ( EventHandle, GraphHandle, - KernelHandle, GraphNodeHandle, + KernelHandle, + OpaqueHandle, + PreparedAttachment, + PreparedChildGraphUpdate, as_cu, as_intptr, - create_event_handle_ref, create_child_graph_handle, + create_event_handle_ref, create_kernel_handle_ref, + graph_commit_attachment, + graph_commit_child_graph_update, + graph_get_attachment, graph_node_get_graph, + graph_prepare_attachment, + graph_prepare_child_graph_update, + make_opaque_py, ) -from cuda.core._utils.cuda_utils cimport HANDLE_RETURN +from cuda.core._utils.cuda_utils cimport HANDLE_RETURN, _parse_fill_value +from cuda.core._utils.version cimport cy_binding_version, cy_driver_version -from cuda.core.graph._host_callback cimport _is_py_host_trampoline +from cuda.core.graph._host_callback cimport ( + _is_py_host_trampoline, + _resolve_host_callback, +) from cuda.core._utils.cuda_utils import driver, handle_return from cuda.core.typing import GraphConditionalType @@ -57,6 +77,54 @@ __all__ = [ cdef bint _has_cuGraphNodeGetParams = False cdef bint _version_checked = False + +cdef void _require_graph_node_update_support() except *: + cdef tuple version = cy_driver_version() + if version < (12, 2, 0): + raise RuntimeError( + "Graph node mutation requires CUDA driver 12.2 or newer; " + f"using driver version {'.'.join(map(str, version))}" + ) + version = cy_binding_version() + if version < (12, 2, 0): + raise RuntimeError( + "Graph node mutation requires cuda.bindings 12.2 or newer; " + f"using cuda.bindings version {'.'.join(map(str, version))}" + ) + + +cdef void _set_definition_node_params( + const GraphNodeHandle& h_node, + cydriver.CUgraphNodeParams* params, + OpaqueHandle owner0, + OpaqueHandle owner1=OpaqueHandle(), + cydriver.CUcontext update_ctx=NULL) except *: + _require_graph_node_update_support() + + cdef GraphHandle h_graph = graph_node_get_graph(h_node) + cdef cydriver.CUgraphNode node = as_cu(h_node) + cdef cydriver.CUcontext previous_ctx = NULL + cdef bint restore_ctx = False + cdef PreparedAttachment prepared + + HANDLE_RETURN(graph_prepare_attachment( + h_graph, owner0, owner1, &prepared)) + if update_ctx != NULL: + with nogil: + HANDLE_RETURN(cydriver.cuCtxGetCurrent(&previous_ctx)) + if previous_ctx != update_ctx: + HANDLE_RETURN(cydriver.cuCtxSetCurrent(update_ctx)) + restore_ctx = True + try: + with nogil: + HANDLE_RETURN(cydriver.cuGraphNodeSetParams(node, params)) + finally: + if restore_ctx: + with nogil: + HANDLE_RETURN(cydriver.cuCtxSetCurrent(previous_ctx)) + HANDLE_RETURN(graph_commit_attachment(prepared, node)) + + cdef bint _check_node_get_params(): global _has_cuGraphNodeGetParams, _version_checked if not _version_checked: @@ -68,6 +136,54 @@ cdef bint _check_node_get_params(): return _has_cuGraphNodeGetParams +cdef void _reject_unsupported_kernel_node( + cydriver.CUgraphNode node) except *: + cdef cydriver.CUkernelNodeAttrValue cluster + cdef cydriver.CUkernelNodeAttrValue cooperative + + c_memset(&cluster, 0, sizeof(cluster)) + c_memset(&cooperative, 0, sizeof(cooperative)) + with nogil: + HANDLE_RETURN(cydriver.cuGraphKernelNodeGetAttribute( + node, ( + cydriver.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION), + &cluster)) + HANDLE_RETURN(cydriver.cuGraphKernelNodeGetAttribute( + node, ( + cydriver.CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE), + &cooperative)) + if (cluster.clusterDim.x != 0 or cluster.clusterDim.y != 0 or + cluster.clusterDim.z != 0 or cooperative.cooperative != 0): + raise NotImplementedError( + "updating clustered or cooperative kernel nodes is not supported") + + +cdef bint _is_supported_memcpy_descriptor( + cydriver.CUDA_MEMCPY3D* params) noexcept nogil: + return ( + (params.srcMemoryType == cydriver.CU_MEMORYTYPE_HOST or + params.srcMemoryType == cydriver.CU_MEMORYTYPE_DEVICE) + and (params.dstMemoryType == cydriver.CU_MEMORYTYPE_HOST or + params.dstMemoryType == cydriver.CU_MEMORYTYPE_DEVICE) + and params.srcXInBytes == 0 + and params.srcY == 0 + and params.srcZ == 0 + and params.srcLOD == 0 + and params.srcPitch == 0 + and params.srcHeight == 0 + and params.dstXInBytes == 0 + and params.dstY == 0 + and params.dstZ == 0 + and params.dstLOD == 0 + and params.dstPitch == 0 + and params.dstHeight == 0 + and params.Height == 1 + and params.Depth == 1 + and params.reserved0 == NULL + and params.reserved1 == NULL + ) + + cdef class EmptyNode(GraphNode): """An empty (synchronization) node.""" @@ -130,6 +246,99 @@ cdef class KernelNode(GraphNode): return (f"") + def update( + self, + *, + config: LaunchConfig | None = None, + kernel: Kernel | None = None, + args=None, + ) -> None: + """Replace selected kernel launch parameters. + + Omitted parameters preserve their current values. Changing ``kernel`` + requires ``args``, including ``args=()`` for a no-argument kernel. + Clustered and cooperative kernel nodes are not supported. + + .. warning:: + + Use caution when a retained kernel argument directly or indirectly + owns a graph. Any reference cycle involving the argument and a + graph that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + cdef LaunchConfig c_config + cdef Kernel c_kernel + cdef ParamHolder arg_holder + cdef object kernel_args + cdef KernelHandle h_kernel = self._h_kernel + cdef OpaqueHandle kernel_owner + cdef OpaqueHandle args_owner + cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) + cdef cydriver.CUgraphNode node = as_cu(self._h_node) + cdef cydriver.CUgraphNodeParams params + + if config is not None: + c_config = config + if (c_config.cluster is not None or + c_config.is_cooperative): + raise NotImplementedError( + "updating clustered or cooperative kernel nodes is not " + "supported") + _require_graph_node_update_support() + _reject_unsupported_kernel_node(node) + if kernel is not None: + if args is None: + raise ValueError("changing kernel requires args") + c_kernel = kernel + h_kernel = c_kernel._h_kernel + if args is not None: + arg_holder = ParamHolder(args) + + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_KERNEL + with nogil: + HANDLE_RETURN(cydriver.cuGraphKernelNodeGetParams( + node, ¶ms.kernel)) + HANDLE_RETURN(graph_get_attachment( + h_graph, node, &kernel_owner, &args_owner)) + + if config is not None: + params.kernel.gridDimX = c_config.grid[0] + params.kernel.gridDimY = c_config.grid[1] + params.kernel.gridDimZ = c_config.grid[2] + params.kernel.blockDimX = c_config.block[0] + params.kernel.blockDimY = c_config.block[1] + params.kernel.blockDimZ = c_config.block[2] + params.kernel.sharedMemBytes = c_config.shmem_size + if kernel is not None: + params.kernel.kern = as_cu(h_kernel) + params.kernel.func = NULL + params.kernel.ctx = NULL + kernel_owner = h_kernel + if args is not None: + params.kernel.kernelParams = arg_holder.ptr + params.kernel.extra = NULL + kernel_args = arg_holder.kernel_args + if kernel_args is None: + args_owner = OpaqueHandle() + else: + args_owner = make_opaque_py(kernel_args) + + _set_definition_node_params( + self._h_node, ¶ms, kernel_owner, args_owner) + self._grid = ( + params.kernel.gridDimX, + params.kernel.gridDimY, + params.kernel.gridDimZ, + ) + self._block = ( + params.kernel.blockDimX, + params.kernel.blockDimY, + params.kernel.blockDimZ, + ) + self._shmem_size = params.kernel.sharedMemBytes + self._h_kernel = h_kernel + @property def grid(self) -> tuple[int, int, int]: """Grid dimensions as a 3-tuple (gridDimX, gridDimY, gridDimZ).""" @@ -340,6 +549,102 @@ cdef class MemsetNode(GraphNode): return (f"") + def update( + self, + *, + dst: Buffer | int | None = None, + value=None, + width: int | None = None, + height: int | None = None, + pitch: int | None = None, + dst_owner=None, + ) -> None: + """Replace selected memset parameters. + + Omitted parameters preserve their current values. ``dst_owner`` may + only accompany a raw-address ``dst``. + + With CUDA 12.2 through 13.1, the node's intended CUDA context must be + current when this method is called. CUDA driver and ``cuda.bindings`` + versions 13.2 and newer preserve the recorded context automatically. + + .. warning:: + + Use caution when a retained operand owner directly or indirectly + owns a graph. Any reference cycle involving the owner and a graph + that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + cdef OpaqueHandle dst_attachment_owner + cdef GraphHandle h_graph + cdef cydriver.CUgraphNode node = as_cu(self._h_node) + cdef cydriver.CUcontext ctx = NULL + cdef cydriver.CUDA_MEMSET_NODE_PARAMS current + cdef cydriver.CUgraphNodeParams params + cdef object queried + + if dst is None and dst_owner is not None: + raise ValueError("dst_owner requires dst") + if (dst is None and value is None and width is None and + height is None and pitch is None): + return + + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_MEMSET + with nogil: + HANDLE_RETURN(cydriver.cuGraphMemsetNodeGetParams( + node, ¤t)) + if _check_node_get_params(): + queried = handle_return(driver.cuGraphNodeGetParams( + node)) + ctx = int(queried.memset.ctx) + else: + with nogil: + HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) + + cdef cydriver.CUdeviceptr c_dst = current.dst + cdef unsigned int c_value = current.value + cdef unsigned int c_element_size = current.elementSize + cdef size_t c_width = current.width + cdef size_t c_height = current.height + cdef size_t c_pitch = current.pitch + + if dst is None: + h_graph = graph_node_get_graph(self._h_node) + HANDLE_RETURN(graph_get_attachment( + h_graph, node, + &dst_attachment_owner, NULL)) + else: + dst_attachment_owner = _resolve_memcpy_operand( + dst, dst_owner, "dst", &c_dst) + + if value is not None: + c_value, c_element_size = _parse_fill_value(value) + if width is not None: + c_width = width + if height is not None: + c_height = height + if pitch is not None: + c_pitch = pitch + + params.memset.dst = c_dst + params.memset.value = c_value + params.memset.elementSize = c_element_size + params.memset.width = c_width + params.memset.height = c_height + params.memset.pitch = c_pitch + params.memset.ctx = ctx + + _set_definition_node_params( + self._h_node, ¶ms, dst_attachment_owner, + OpaqueHandle(), params.memset.ctx) + self._dptr = c_dst + self._value = c_value + self._element_size = c_element_size + self._width = c_width + self._height = c_height + self._pitch = c_pitch + @property def dptr(self) -> int: """The destination device pointer.""" @@ -428,6 +733,133 @@ cdef class MemcpyNode(GraphNode): return (f"") + def update( + self, + *, + dst: Buffer | int | None = None, + src: Buffer | int | None = None, + size: int | None = None, + dst_owner=None, + src_owner=None, + ) -> None: + """Replace selected memcpy parameters. + + Omitted parameters preserve their current values. ``dst_owner`` and + ``src_owner`` may only accompany their corresponding raw addresses. + Multidimensional, pitched, offset, and array-backed memcpy nodes are + not supported. + + With CUDA 12.2 through 13.1, the node's intended CUDA context must be + current when this method is called. CUDA driver and ``cuda.bindings`` + versions 13.2 and newer preserve the recorded context automatically. + + .. warning:: + + Use caution when a retained operand owner directly or indirectly + owns a graph. Any reference cycle involving the owner and a graph + that retains it cannot be broken by Python's cyclic garbage + collector. Use a weak reference to break such cycles. + """ + cdef cydriver.CUdeviceptr c_dst = self._dst + cdef cydriver.CUdeviceptr c_src = self._src + cdef OpaqueHandle dst_attachment_owner + cdef OpaqueHandle src_attachment_owner + cdef GraphHandle h_graph = graph_node_get_graph(self._h_node) + cdef cydriver.CUgraphNode node = as_cu(self._h_node) + cdef cydriver.CUcontext ctx = NULL + cdef cydriver.CUgraphNodeParams params + cdef cydriver.CUmemorytype c_dst_type + cdef cydriver.CUmemorytype c_src_type + cdef object queried + + if dst is None and dst_owner is not None: + raise ValueError("dst_owner requires dst") + if src is None and src_owner is not None: + raise ValueError("src_owner requires src") + if dst is None and src is None and size is None: + return + + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_MEMCPY + with nogil: + HANDLE_RETURN(cydriver.cuGraphMemcpyNodeGetParams( + node, ¶ms.memcpy.copyParams)) + if _check_node_get_params(): + queried = handle_return(driver.cuGraphNodeGetParams( + node)) + ctx = int( + queried.memcpy.copyCtx) + else: + with nogil: + HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) + params.memcpy.copyCtx = ctx + + if not _is_supported_memcpy_descriptor(¶ms.memcpy.copyParams): + raise NotImplementedError( + "updating multidimensional, pitched, offset, or array-backed " + "memcpy nodes is not supported") + + c_dst_type = params.memcpy.copyParams.dstMemoryType + c_src_type = params.memcpy.copyParams.srcMemoryType + if c_dst_type == cydriver.CU_MEMORYTYPE_HOST: + c_dst = ( + params.memcpy.copyParams.dstHost) + elif c_dst_type == cydriver.CU_MEMORYTYPE_DEVICE: + c_dst = params.memcpy.copyParams.dstDevice + else: + raise NotImplementedError( + f"unsupported destination memory type: {int(c_dst_type)}") + if c_src_type == cydriver.CU_MEMORYTYPE_HOST: + c_src = ( + params.memcpy.copyParams.srcHost) + elif c_src_type == cydriver.CU_MEMORYTYPE_DEVICE: + c_src = params.memcpy.copyParams.srcDevice + else: + raise NotImplementedError( + f"unsupported source memory type: {int(c_src_type)}") + + HANDLE_RETURN(graph_get_attachment( + h_graph, node, + &dst_attachment_owner, &src_attachment_owner)) + if dst is not None: + dst_attachment_owner = _resolve_memcpy_operand( + dst, dst_owner, "dst", &c_dst) + c_dst_type = _get_memcpy_memory_type(c_dst) + params.memcpy.copyParams.dstMemoryType = c_dst_type + params.memcpy.copyParams.dstHost = NULL + params.memcpy.copyParams.dstDevice = 0 + params.memcpy.copyParams.dstArray = NULL + params.memcpy.copyParams.reserved1 = NULL + if c_dst_type == cydriver.CU_MEMORYTYPE_HOST: + params.memcpy.copyParams.dstHost = c_dst + else: + params.memcpy.copyParams.dstDevice = c_dst + if src is not None: + src_attachment_owner = _resolve_memcpy_operand( + src, src_owner, "src", &c_src) + c_src_type = _get_memcpy_memory_type(c_src) + params.memcpy.copyParams.srcMemoryType = c_src_type + params.memcpy.copyParams.srcHost = NULL + params.memcpy.copyParams.srcDevice = 0 + params.memcpy.copyParams.srcArray = NULL + params.memcpy.copyParams.reserved0 = NULL + if c_src_type == cydriver.CU_MEMORYTYPE_HOST: + params.memcpy.copyParams.srcHost = c_src + else: + params.memcpy.copyParams.srcDevice = c_src + if size is not None: + params.memcpy.copyParams.WidthInBytes = size + + _set_definition_node_params( + self._h_node, ¶ms, + dst_attachment_owner, src_attachment_owner, + params.memcpy.copyCtx) + self._dst = c_dst + self._src = c_src + self._size = params.memcpy.copyParams.WidthInBytes + self._dst_type = c_dst_type + self._src_type = c_src_type + @property def dst(self) -> int: """The destination pointer.""" @@ -478,6 +910,37 @@ cdef class ChildGraphNode(GraphNode): return (f"") + def update(self, child: GraphDefinition) -> None: + """Replace the embedded graph with a clone of ``child``. + + ``child`` must belong to an independent graph hierarchy. + """ + cdef GraphHandle h_parent = graph_node_get_graph(self._h_node) + cdef GraphHandle h_replacement + cdef cydriver.CUgraphNode node = as_cu(self._h_node) + cdef cydriver.CUgraphNodeParams params + cdef cydriver.CUresult commit_status + cdef PreparedChildGraphUpdate prepared + + _require_graph_node_update_support() + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_GRAPH + params.graph.graph = as_cu(child._h_graph) + + HANDLE_RETURN(graph_prepare_child_graph_update( + h_parent, self._h_child_graph, node, + child._h_graph, &prepared)) + with nogil: + HANDLE_RETURN(cydriver.cuGraphNodeSetParams( + node, ¶ms)) + try: + commit_status = graph_commit_child_graph_update( + prepared, &h_replacement) + finally: + if h_replacement: + self._h_child_graph = h_replacement + HANDLE_RETURN(commit_status) + @property def child_graph(self) -> GraphDefinition: """The embedded graph definition (non-owning wrapper).""" @@ -516,6 +979,19 @@ cdef class EventRecordNode(GraphNode): return (f"") + def update(self, event: Event) -> None: + """Replace the event recorded by this node.""" + cdef OpaqueHandle event_owner = event._h_event + cdef cydriver.CUgraphNodeParams params + + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_EVENT_RECORD + params.eventRecord.event = as_cu(event._h_event) + + _set_definition_node_params( + self._h_node, ¶ms, event_owner) + self._h_event = event._h_event + @property def event(self) -> Event: """The event being recorded.""" @@ -554,6 +1030,19 @@ cdef class EventWaitNode(GraphNode): return (f"") + def update(self, event: Event) -> None: + """Replace the event waited on by this node.""" + cdef OpaqueHandle event_owner = event._h_event + cdef cydriver.CUgraphNodeParams params + + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_WAIT_EVENT + params.eventWait.event = as_cu(event._h_event) + + _set_definition_node_params( + self._h_node, ¶ms, event_owner) + self._h_event = event._h_event + @property def event(self) -> Event: """The event being waited on.""" @@ -604,6 +1093,37 @@ cdef class HostCallbackNode(GraphNode): return (f"self._fn:x}>") + def update(self, fn, *, user_data=None) -> None: + """Replace the callback and user-data binding for this node. + + .. warning:: + + Callbacks must not call CUDA API functions. Doing so may + deadlock or corrupt driver state. + + Use caution when a Python callback retains an object that owns a + graph. Any reference cycle involving the callback and a graph that + retains it cannot be broken by Python's cyclic garbage collector. + Use a weak reference to break such cycles. + """ + cdef cydriver.CUhostFn c_fn + cdef void* c_user_data + cdef OpaqueHandle fn_owner, data_owner + cdef cydriver.CUgraphNodeParams params + + _resolve_host_callback( + fn, user_data, &c_fn, &c_user_data, &fn_owner, &data_owner) + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_HOST + params.host.fn = c_fn + params.host.userData = c_user_data + + _set_definition_node_params( + self._h_node, ¶ms, fn_owner, data_owner) + self._callable = fn if _is_py_host_trampoline(c_fn) else None + self._fn = c_fn + self._user_data = c_user_data + @property def callback(self): """The Python callable, or None for ctypes function pointer callbacks.""" diff --git a/cuda_core/docs/source/api.rst b/cuda_core/docs/source/api.rst index 089e68576c9..da18ee27c80 100644 --- a/cuda_core/docs/source/api.rst +++ b/cuda_core/docs/source/api.rst @@ -154,6 +154,22 @@ Every graph node is a subclass of :class:`~graph.GraphNode`, which provides the common interface (dependencies, successors, destruction). Each subclass exposes attributes unique to its operation type. +Parameter-bearing definition nodes expose subclass-specific ``update()`` +methods: :class:`~graph.KernelNode`, :class:`~graph.MemcpyNode`, +:class:`~graph.MemsetNode`, :class:`~graph.ChildGraphNode`, +:class:`~graph.EventRecordNode`, :class:`~graph.EventWaitNode`, and +:class:`~graph.HostCallbackNode`. These methods require CUDA driver and +``cuda.bindings`` versions 12.2 or newer. Updates affect future graph +instantiations; executable graphs that were already instantiated continue +using their previous parameters and retained resources. Omitted optional +arguments preserve their current values where supported. +On CUDA 12.2 through 13.1, the intended CUDA context must be current when +updating memcpy or memset nodes. CUDA driver and ``cuda.bindings`` versions +13.2 and newer preserve the recorded context automatically. +Multidimensional or array-backed memcpy nodes and clustered or cooperative +kernel nodes cannot currently be updated. Clustered and cooperative kernel +nodes also cannot currently be constructed explicitly. + .. autosummary:: :toctree: generated/ diff --git a/cuda_core/docs/source/release/1.2.0-notes.rst b/cuda_core/docs/source/release/1.2.0-notes.rst index 6a047c9cfe8..de255d01cbb 100644 --- a/cuda_core/docs/source/release/1.2.0-notes.rst +++ b/cuda_core/docs/source/release/1.2.0-notes.rst @@ -18,6 +18,13 @@ Fixes and enhancements (`#2357 `__, `#2371 `__) +- Added ``update()`` methods to kernel, memcpy, memset, child-graph, event + record, event wait, and host-callback graph definition nodes. Updates change + parameters used by future graph instantiations without affecting existing + executable graphs. This feature requires CUDA driver and ``cuda.bindings`` + versions 12.2 or newer. + (`#2352 `__) + Deprecation Notices ------------------- diff --git a/cuda_core/tests/graph/test_graph_definition_lifetime.py b/cuda_core/tests/graph/test_graph_definition_lifetime.py index 804cccc1923..1364f437ea6 100644 --- a/cuda_core/tests/graph/test_graph_definition_lifetime.py +++ b/cuda_core/tests/graph/test_graph_definition_lifetime.py @@ -77,6 +77,8 @@ def _wait_until(predicate, timeout=None, interval=0.02): from cuda.core import Device, DeviceMemoryResource, EventOptions, Kernel, LaunchConfig +from cuda.core._utils.cuda_utils import CUDAError +from cuda.core._utils.version import driver_version from cuda.core.graph import ( ChildGraphNode, ConditionalNode, @@ -424,6 +426,97 @@ def test_destroying_child_node_invalidates_embedded_handles(init_cuda): assert not embedded_callback.is_valid +@pytest.mark.agent_authored(model="gpt-5.6") +def test_updating_child_node_replaces_embedded_handles(init_cuda): + """A successful replacement invalidates only the old embedded hierarchy.""" + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + old_inner = GraphDefinition() + old_inner.callback(lambda: None) + old_middle = GraphDefinition() + old_middle.embed(old_inner) + parent = GraphDefinition() + child_node = parent.embed(old_middle) + + embedded_middle = child_node.child_graph + embedded_child = next(node for node in embedded_middle.nodes() if isinstance(node, ChildGraphNode)) + embedded_inner = embedded_child.child_graph + embedded_callback = next(node for node in embedded_inner.nodes() if isinstance(node, HostCallbackNode)) + + # Sources from the destination hierarchy may contain handles CUDA destroys + # during replacement, so cuda-core rejects them before mutation. + with pytest.raises(CUDAError): + child_node.update(embedded_middle) + with pytest.raises(CUDAError): + child_node.update(parent) + assert int(embedded_middle.handle) != 0 + assert int(embedded_inner.handle) != 0 + assert embedded_child.is_valid + assert embedded_callback.is_valid + + replacement_inner = GraphDefinition() + replacement_inner.callback(lambda: None) + replacement_middle = GraphDefinition() + replacement_middle.embed(replacement_inner) + child_node.update(replacement_middle) + + assert child_node.is_valid + assert int(embedded_middle.handle) == 0 + assert int(embedded_inner.handle) == 0 + assert not embedded_child.is_valid + assert not embedded_callback.is_valid + + new_middle = child_node.child_graph + new_child = next(node for node in new_middle.nodes() if isinstance(node, ChildGraphNode)) + assert int(new_middle.handle) != 0 + assert int(new_child.child_graph.handle) != 0 + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_child_update_replaces_nested_attachments(init_cuda): + """Replacement drops old owners and imports nested replacement owners.""" + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + def old_callback(): + pass + + old_callback_weak = weakref.ref(old_callback) + old_child = GraphDefinition() + old_child.callback(old_callback) + parent = GraphDefinition() + child_node = parent.embed(old_child) + + del old_callback, old_child + gc.collect() + assert old_callback_weak() is not None + + def replacement_callback(): + pass + + replacement_callback_weak = weakref.ref(replacement_callback) + replacement_inner = GraphDefinition() + replacement_inner.callback(replacement_callback) + replacement = GraphDefinition() + replacement.embed(replacement_inner) + child_node.update(replacement) + + _wait_until(lambda: old_callback_weak() is None) + del replacement_callback, replacement_inner, replacement + gc.collect() + assert replacement_callback_weak() is not None + + embedded = child_node.child_graph + embedded_child = next(node for node in embedded.nodes() if isinstance(node, ChildGraphNode)) + embedded_callback = next(node for node in embedded_child.child_graph.nodes() if isinstance(node, HostCallbackNode)) + assert embedded_callback.callback is replacement_callback_weak() + + del embedded_callback, embedded_child, embedded + child_node.destroy() + _wait_until(lambda: replacement_callback_weak() is None) + + @pytest.mark.agent_authored(model="gpt-5.6") def test_builder_embedded_clone_releases_attachment_on_node_destroy(init_cuda): """GraphBuilder.embed imports metadata from the captured child graph.""" diff --git a/cuda_core/tests/graph/test_graph_node_update.py b/cuda_core/tests/graph/test_graph_node_update.py new file mode 100644 index 00000000000..2dce7a39317 --- /dev/null +++ b/cuda_core/tests/graph/test_graph_node_update.py @@ -0,0 +1,741 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Tests for updating individual graph node parameters.""" + +import ctypes +import threading +from dataclasses import dataclass +from typing import Callable + +import pytest +from helpers.graph_kernels import compile_common_kernels + +from cuda.core import LaunchConfig, LegacyPinnedMemoryResource +from cuda.core._utils.cuda_utils import CUDAError, driver, handle_return +from cuda.core._utils.version import driver_version +from cuda.core.graph import GraphDefinition, HostCallbackNode + + +@dataclass +class _DefinitionUpdateCase: + graph_def: GraphDefinition + node: object + original: object + replacement: object + update: Callable[[object], None] + assert_current: Callable[[object], None] + assert_exec_uses: Callable[[object, object], None] + invalid_update: Callable[[], None] | None + invalid_exception: type[BaseException] | None + invalid_argument_update: Callable[[], None] | None + + +def _assert_equal(actual, expected): + assert actual == expected + + +def _event_record_case(device): + """Keep the selected event pending to identify each exec's record target.""" + original = device.create_event() + replacement = device.create_event() + invalid_replacement = device.create_event() + invalid_replacement.close() + + callback_started = threading.Event() + callback_release = threading.Event() + + def blocking_callback(): + callback_started.set() + callback_release.wait(timeout=30) + + graph_def = GraphDefinition() + callback_node = graph_def.callback(blocking_callback) + node = callback_node.record(original) + + def assert_exec_uses(graph, expected): + callback_started.clear() + callback_release.clear() + stream = device.create_stream() + graph.launch(stream) + try: + assert callback_started.wait(timeout=5) + assert expected.is_done is False + unexpected = replacement if expected is original else original + assert unexpected.is_done is True + finally: + callback_release.set() + stream.sync() + + return _DefinitionUpdateCase( + graph_def=graph_def, + node=node, + original=original, + replacement=replacement, + update=node.update, + assert_current=lambda expected: _assert_equal(node.event, expected), + assert_exec_uses=assert_exec_uses, + invalid_update=lambda: node.update(invalid_replacement), + invalid_exception=CUDAError, + invalid_argument_update=lambda: node.update(object()), + ) + + +def _event_wait_case(device): + """Keep the selected event pending to identify each exec's wait target.""" + original = device.create_event() + replacement = device.create_event() + invalid_replacement = device.create_event() + invalid_replacement.close() + + callback_called = threading.Event() + graph_def = GraphDefinition() + node = graph_def.wait(original) + node.callback(callback_called.set) + + def assert_exec_uses(graph, expected): + producer_started = threading.Event() + producer_release = threading.Event() + + def blocking_callback(): + producer_started.set() + producer_release.wait(timeout=30) + + producer_def = GraphDefinition() + producer_def.callback(blocking_callback).record(expected) + producer_graph = producer_def.instantiate() + producer_stream = device.create_stream() + consumer_stream = device.create_stream() + + callback_called.clear() + producer_graph.launch(producer_stream) + try: + assert producer_started.wait(timeout=5) + graph.launch(consumer_stream) + assert not callback_called.wait(timeout=0.1) + finally: + producer_release.set() + producer_stream.sync() + consumer_stream.sync() + assert callback_called.is_set() + + return _DefinitionUpdateCase( + graph_def=graph_def, + node=node, + original=original, + replacement=replacement, + update=node.update, + assert_current=lambda expected: _assert_equal(node.event, expected), + assert_exec_uses=assert_exec_uses, + invalid_update=lambda: node.update(invalid_replacement), + invalid_exception=CUDAError, + invalid_argument_update=lambda: node.update(object()), + ) + + +def _host_callback_case(device): + """Use callbacks that report their identity to distinguish each exec.""" + called = [] + + def original(): + called.append(original) + + def replacement(): + called.append(replacement) + + graph_def = GraphDefinition() + node = graph_def.callback(original) + + def assert_exec_uses(graph, expected): + called.clear() + stream = device.create_stream() + graph.launch(stream) + stream.sync() + assert called == [expected] + + return _DefinitionUpdateCase( + graph_def=graph_def, + node=node, + original=original, + replacement=replacement, + update=node.update, + assert_current=lambda expected: _assert_equal(node.callback, expected), + assert_exec_uses=assert_exec_uses, + invalid_update=lambda: node.update(replacement, user_data=b"not valid for a Python callback"), + invalid_exception=ValueError, + invalid_argument_update=lambda: node.update(object()), + ) + + +def _host_callback_ctypes_case(device): + """Use ctypes callbacks and copied payloads to distinguish each exec.""" + callback_type = ctypes.CFUNCTYPE(None, ctypes.c_void_p) + called = [] + + def read_byte(data): + return ctypes.cast(data, ctypes.POINTER(ctypes.c_uint8))[0] + + @callback_type + def original_fn(data): + called.append((original_fn, read_byte(data))) + + @callback_type + def replacement_fn(data): + called.append((replacement_fn, read_byte(data))) + + original = original_fn, bytes([0xA1]) + replacement = replacement_fn, bytes([0xB2]) + graph_def = GraphDefinition() + node = graph_def.callback(original_fn, user_data=original[1]) + + def update(value): + fn, user_data = value + node.update(fn, user_data=user_data) + + def assert_exec_uses(graph, expected): + called.clear() + stream = device.create_stream() + graph.launch(stream) + stream.sync() + assert called == [(expected[0], expected[1][0])] + + def invalid_update(): + node.update(lambda: None, user_data=b"not valid for a Python callback") + + return _DefinitionUpdateCase( + graph_def=graph_def, + node=node, + original=original, + replacement=replacement, + update=update, + assert_current=lambda _expected: _assert_equal(node.callback, None), + assert_exec_uses=assert_exec_uses, + invalid_update=invalid_update, + invalid_exception=ValueError, + invalid_argument_update=None, + ) + + +def _memset_case(device, *, replace_dst): + memory_resource = LegacyPinnedMemoryResource() + original_buffer = memory_resource.allocate(4) + replacement_buffer = memory_resource.allocate(4) if replace_dst else original_buffer + original = { + "dst": original_buffer, + "value": 0x11, + "element_size": 1, + "width": 4, + "height": 1, + "pitch": 0, + } + replacement = { + **original, + "dst": replacement_buffer, + "value": 0x22, + } + + graph_def = GraphDefinition() + node = graph_def.memset(original["dst"], original["value"], original["width"]) + + def update(expected): + if replace_dst: + node.update(dst=expected["dst"], value=expected["value"]) + else: + node.update(value=expected["value"]) + + def assert_current(expected): + assert node.dptr == int(expected["dst"].handle) + assert node.value == expected["value"] + assert node.element_size == expected["element_size"] + assert node.width == expected["width"] + assert node.height == expected["height"] + assert node.pitch == expected["pitch"] + + def as_bytes(buffer): + return (ctypes.c_uint8 * 4).from_address(int(buffer.handle)) + + def assert_exec_uses(graph, expected): + original_data = as_bytes(original_buffer) + replacement_data = as_bytes(replacement_buffer) + original_data[:] = [0] * 4 + replacement_data[:] = [0] * 4 + + stream = device.create_stream() + graph.launch(stream) + stream.sync() + + assert list(as_bytes(expected["dst"])) == [expected["value"]] * 4 + if replace_dst: + unexpected = replacement_buffer if expected["dst"] is original_buffer else original_buffer + assert list(as_bytes(unexpected)) == [0] * 4 + + return _DefinitionUpdateCase( + graph_def=graph_def, + node=node, + original=original, + replacement=replacement, + update=update, + assert_current=assert_current, + assert_exec_uses=assert_exec_uses, + invalid_update=lambda: node.update(value=256), + invalid_exception=OverflowError, + invalid_argument_update=lambda: node.update(dst=object()), + ) + + +def _memset_value_case(device): + """Change the fill value while preserving destination ownership.""" + return _memset_case(device, replace_dst=False) + + +def _memset_destination_case(device): + """Replace the destination and its retained allocation owner.""" + return _memset_case(device, replace_dst=True) + + +def _memcpy_case(device, *, replace_operand): + memory_resource = LegacyPinnedMemoryResource() + original_src = memory_resource.allocate(4) + original_dst = memory_resource.allocate(4) + replacement_src = memory_resource.allocate(4) if replace_operand == "src" else original_src + replacement_dst = memory_resource.allocate(4) if replace_operand == "dst" else original_dst + original = { + "dst": original_dst, + "src": original_src, + "size": 2 if replace_operand is None else 4, + } + replacement = { + "dst": replacement_dst, + "src": replacement_src, + "size": 4, + } + + graph_def = GraphDefinition() + node = graph_def.memcpy(original["dst"], original["src"], original["size"]) + + def update(expected): + if replace_operand == "src": + node.update(src=expected["src"]) + elif replace_operand == "dst": + node.update(dst=expected["dst"]) + else: + node.update(size=expected["size"]) + + def assert_current(expected): + assert node.dst == int(expected["dst"].handle) + assert node.src == int(expected["src"].handle) + assert node.size == expected["size"] + + def as_bytes(buffer): + return (ctypes.c_uint8 * 4).from_address(int(buffer.handle)) + + def assert_exec_uses(graph, expected): + as_bytes(original_src)[:] = [0x11] * 4 + as_bytes(original_dst)[:] = [0] * 4 + if replacement_src is not original_src: + as_bytes(replacement_src)[:] = [0x22] * 4 + if replacement_dst is not original_dst: + as_bytes(replacement_dst)[:] = [0] * 4 + + stream = device.create_stream() + graph.launch(stream) + stream.sync() + + source_value = 0x11 if expected["src"] is original_src else 0x22 + expected_data = [source_value] * expected["size"] + expected_data.extend([0] * (4 - expected["size"])) + assert list(as_bytes(expected["dst"])) == expected_data + if replacement_dst is not original_dst: + unexpected_dst = replacement_dst if expected["dst"] is original_dst else original_dst + assert list(as_bytes(unexpected_dst)) == [0] * 4 + + return _DefinitionUpdateCase( + graph_def=graph_def, + node=node, + original=original, + replacement=replacement, + update=update, + assert_current=assert_current, + assert_exec_uses=assert_exec_uses, + invalid_update=lambda: node.update(size=-1), + invalid_exception=OverflowError, + invalid_argument_update=lambda: node.update(src=object()), + ) + + +def _memcpy_size_case(device): + """Change the copy size while preserving both operand owners.""" + return _memcpy_case(device, replace_operand=None) + + +def _memcpy_source_case(device): + """Replace the source while preserving destination ownership.""" + return _memcpy_case(device, replace_operand="src") + + +def _memcpy_destination_case(device): + """Replace the destination while preserving source ownership.""" + return _memcpy_case(device, replace_operand="dst") + + +def _kernel_case(device, *, replace): + module = compile_common_kernels() + add_one = module.get_kernel("add_one") + empty_kernel = module.get_kernel("empty_kernel") + write_launch_dims = module.get_kernel("write_launch_dims") + memory_resource = LegacyPinnedMemoryResource() + original_buffer = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) + replacement_buffer = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) if replace == "args" else original_buffer + + original_config = LaunchConfig(grid=1, block=1) + replacement_config = LaunchConfig(grid=2, block=3) if replace == "config" else original_config + original_kernel = write_launch_dims if replace == "config" else add_one + replacement_kernel = empty_kernel if replace == "kernel" else original_kernel + original_args = (original_buffer,) + if replace == "kernel": + replacement_args = () + elif replace == "args": + replacement_args = (replacement_buffer,) + else: + replacement_args = original_args + + original = { + "config": original_config, + "kernel": original_kernel, + "args": original_args, + "output": original_buffer, + "expected": 1001 if replace == "config" else 1, + } + replacement = { + "config": replacement_config, + "kernel": replacement_kernel, + "args": replacement_args, + "output": replacement_buffer, + "expected": 2003 if replace == "config" else int(replace != "kernel"), + } + + graph_def = GraphDefinition() + node = graph_def.launch(original["config"], original["kernel"], *original["args"]) + + def update(expected): + if replace == "config": + node.update(config=expected["config"]) + elif replace == "args": + node.update(args=expected["args"]) + else: + node.update(kernel=expected["kernel"], args=expected["args"]) + + def assert_current(expected): + assert node.config == expected["config"] + assert int(node.kernel.handle) == int(expected["kernel"].handle) + + def as_int(buffer): + return ctypes.c_int.from_address(int(buffer.handle)) + + def assert_exec_uses(graph, expected): + as_int(original_buffer).value = 0 + as_int(replacement_buffer).value = 0 + + stream = device.create_stream() + graph.launch(stream) + stream.sync() + + assert as_int(expected["output"]).value == expected["expected"] + if replacement_buffer is not original_buffer: + unexpected = replacement_buffer if expected["output"] is original_buffer else original_buffer + assert as_int(unexpected).value == 0 + + def invalid_update(): + if replace == "kernel": + node.update(kernel=replacement_kernel) + elif replace == "args": + node.update(args=(object(),)) + else: + node.update(config=object()) + + invalid_exception = ValueError if replace == "kernel" else TypeError + + return _DefinitionUpdateCase( + graph_def=graph_def, + node=node, + original=original, + replacement=replacement, + update=update, + assert_current=assert_current, + assert_exec_uses=assert_exec_uses, + invalid_update=invalid_update, + invalid_exception=invalid_exception, + invalid_argument_update=lambda: node.update(config=object()), + ) + + +def _kernel_config_case(device): + """Replace launch dimensions while preserving the kernel and arguments.""" + return _kernel_case(device, replace="config") + + +def _kernel_args_case(device): + """Replace arguments while preserving the kernel and configuration.""" + return _kernel_case(device, replace="args") + + +def _kernel_function_case(device): + """Replace a kernel and explicitly supply its coupled arguments.""" + return _kernel_case(device, replace="kernel") + + +def _child_graph_case(device): + """Replace the embedded clone while preserving existing executables.""" + called = [] + + def original_callback(): + called.append(original_callback) + + def replacement_callback(): + called.append(replacement_callback) + + original_child = GraphDefinition() + original_child.callback(original_callback) + replacement_child = GraphDefinition() + replacement_child.callback(replacement_callback) + original = { + "child": original_child, + "callback": original_callback, + } + replacement = { + "child": replacement_child, + "callback": replacement_callback, + } + + graph_def = GraphDefinition() + node = graph_def.embed(original_child) + invalid_child = node.child_graph + + def update(expected): + node.update(expected["child"]) + + def assert_current(expected): + callback_node = next( + child_node for child_node in node.child_graph.nodes() if isinstance(child_node, HostCallbackNode) + ) + assert callback_node.callback is expected["callback"] + + def assert_exec_uses(graph, expected): + called.clear() + stream = device.create_stream() + graph.launch(stream) + stream.sync() + assert called == [expected["callback"]] + + return _DefinitionUpdateCase( + graph_def=graph_def, + node=node, + original=original, + replacement=replacement, + update=update, + assert_current=assert_current, + assert_exec_uses=assert_exec_uses, + invalid_update=lambda: node.update(invalid_child), + invalid_exception=CUDAError, + invalid_argument_update=lambda: node.update(object()), + ) + + +@pytest.fixture( + params=[ + pytest.param(_event_record_case, id="event-record"), + pytest.param(_event_wait_case, id="event-wait"), + pytest.param(_host_callback_case, id="host-callback-python"), + pytest.param(_host_callback_ctypes_case, id="host-callback-ctypes"), + pytest.param(_memset_value_case, id="memset-value"), + pytest.param(_memset_destination_case, id="memset-destination"), + pytest.param(_memcpy_size_case, id="memcpy-size"), + pytest.param(_memcpy_source_case, id="memcpy-source"), + pytest.param(_memcpy_destination_case, id="memcpy-destination"), + pytest.param(_kernel_config_case, id="kernel-config"), + pytest.param(_kernel_args_case, id="kernel-args"), + pytest.param(_kernel_function_case, id="kernel-function"), + pytest.param(_child_graph_case, id="child-graph"), + ] +) +def definition_update_case(request, init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + return request.param(init_cuda) + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_memcpy_update_rejects_unsupported_descriptor(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + memory_resource = LegacyPinnedMemoryResource() + src = memory_resource.allocate(8) + dst = memory_resource.allocate(8) + graph_def = GraphDefinition() + node = graph_def.memcpy(dst, src, 4) + + # cuda.core cannot construct this descriptor, but imported graphs can + # contain one; use cuda.bindings to exercise that rejection path. + params = driver.CUDA_MEMCPY3D() + params.srcXInBytes = 1 + params.srcMemoryType = driver.CUmemorytype.CU_MEMORYTYPE_HOST + params.srcHost = int(src.handle) + params.srcPitch = 4 + params.srcHeight = 2 + params.dstMemoryType = driver.CUmemorytype.CU_MEMORYTYPE_HOST + params.dstHost = int(dst.handle) + params.dstPitch = 4 + params.dstHeight = 2 + params.WidthInBytes = 2 + params.Height = 2 + params.Depth = 1 + handle_return(driver.cuGraphMemcpyNodeSetParams(node.handle, params)) + + with pytest.raises(NotImplementedError, match="multidimensional"): + node.update(size=3) + + unchanged = handle_return(driver.cuGraphMemcpyNodeGetParams(node.handle)) + assert unchanged.srcXInBytes == 1 + assert unchanged.WidthInBytes == 2 + assert unchanged.Height == 2 + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_kernel_update_rejects_unsupported_config(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + kernel = compile_common_kernels().get_kernel("empty_kernel") + graph_def = GraphDefinition() + node = graph_def.launch(LaunchConfig(grid=1, block=1), kernel) + + clustered = LaunchConfig(grid=1, block=1) + clustered.cluster = (1, 1, 1) + with pytest.raises(NotImplementedError, match="clustered or cooperative"): + node.update(config=clustered) + with pytest.raises(NotImplementedError, match="clustered or cooperative"): + graph_def.launch(clustered, kernel) + + cooperative = LaunchConfig(grid=1, block=1) + cooperative.is_cooperative = True + with pytest.raises(NotImplementedError, match="clustered or cooperative"): + node.update(config=cooperative) + with pytest.raises(NotImplementedError, match="clustered or cooperative"): + graph_def.launch(cooperative, kernel) + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_partial_memory_updates_are_keyword_only(init_cuda): + memory_resource = LegacyPinnedMemoryResource() + src = memory_resource.allocate(4) + dst = memory_resource.allocate(4) + graph_def = GraphDefinition() + memset_node = graph_def.memset(dst, 0, 4) + memcpy_node = graph_def.memcpy(dst, src, 4) + + with pytest.raises(TypeError): + memset_node.update(dst) + with pytest.raises(TypeError): + memcpy_node.update(dst) + + +@pytest.mark.parametrize( + "device_operand", + [ + pytest.param("src", id="device-to-host"), + pytest.param("dst", id="host-to-device"), + ], +) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_memcpy_update_between_host_and_device(init_cuda, device_operand): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + memory_resource = LegacyPinnedMemoryResource() + host_src = memory_resource.allocate(4) + host_dst = memory_resource.allocate(4) + host_src_bytes = (ctypes.c_uint8 * 4).from_address(int(host_src.handle)) + host_dst_bytes = (ctypes.c_uint8 * 4).from_address(int(host_dst.handle)) + host_src_bytes[:] = [0x5A] * 4 + host_dst_bytes[:] = [0] * 4 + + stream = init_cuda.create_stream() + device_buffer = init_cuda.memory_resource.allocate(4, stream=stream) + device_buffer.fill(0, stream=stream) + if device_operand == "src": + device_buffer.copy_from(host_src, stream=stream) + stream.sync() + + graph_def = GraphDefinition() + node = graph_def.memcpy(host_dst, host_src, 4) + if device_operand == "src": + node.update(src=device_buffer) + else: + node.update(dst=device_buffer) + + graph = graph_def.instantiate() + graph.launch(stream) + if device_operand == "dst": + device_buffer.copy_to(host_dst, stream=stream) + stream.sync() + + assert list(host_dst_bytes) == [0x5A] * 4 + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_definition_node_update_changes_future_instantiations( + definition_update_case, +): + case = definition_update_case + assert case.original != case.replacement + old_graph = case.graph_def.instantiate() + + case.update(case.replacement) + case.assert_current(case.replacement) + + new_graph = case.graph_def.instantiate() + assert old_graph != new_graph + case.assert_exec_uses(old_graph, case.original) + case.assert_exec_uses(new_graph, case.replacement) + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_destroyed_definition_node_rejects_update( + definition_update_case, +): + case = definition_update_case + case.node.destroy() + + assert not case.node.is_valid + assert case.node not in case.graph_def.nodes() + with pytest.raises(CUDAError): + case.update(case.replacement) + assert not case.node.is_valid + assert case.node not in case.graph_def.nodes() + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_failed_definition_node_update_preserves_state( + definition_update_case, +): + case = definition_update_case + + assert case.invalid_update is not None + assert case.invalid_exception is not None + with pytest.raises(case.invalid_exception): + case.invalid_update() + + case.assert_current(case.original) + graph = case.graph_def.instantiate() + case.assert_exec_uses(graph, case.original) + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_definition_node_update_rejects_wrong_type( + definition_update_case, +): + if definition_update_case.invalid_argument_update is None: + pytest.skip("update method has no typed positional argument") + with pytest.raises(TypeError): + definition_update_case.invalid_argument_update() diff --git a/cuda_core/tests/helpers/graph_kernels.py b/cuda_core/tests/helpers/graph_kernels.py index 54caedd165c..d08837585fe 100644 --- a/cuda_core/tests/helpers/graph_kernels.py +++ b/cuda_core/tests/helpers/graph_kernels.py @@ -19,15 +19,24 @@ def compile_common_kernels(): Returns a module with: - empty_kernel: does nothing - add_one: increments an int pointer by 1 + - write_launch_dims: encodes the launch dimensions in an int """ code = """ __global__ void empty_kernel() {} __global__ void add_one(int *a) { *a += 1; } + __global__ void write_launch_dims(int *a) { + if (blockIdx.x == 0 && threadIdx.x == 0) { + *a = gridDim.x * 1000 + blockDim.x; + } + } """ arch = "".join(f"{i}" for i in Device().compute_capability) program_options = ProgramOptions(std="c++17", arch=f"sm_{arch}") prog = Program(code, code_type="c++", options=program_options) - mod = prog.compile("cubin", name_expressions=("empty_kernel", "add_one")) + mod = prog.compile( + "cubin", + name_expressions=("empty_kernel", "add_one", "write_launch_dims"), + ) return mod diff --git a/cuda_core/tests/test_green_context.py b/cuda_core/tests/test_green_context.py index a42178031cc..24ad6db482b 100644 --- a/cuda_core/tests/test_green_context.py +++ b/cuda_core/tests/test_green_context.py @@ -21,7 +21,9 @@ WorkqueueResourceOptions, launch, ) -from cuda.core._utils.cuda_utils import CUDAError +from cuda.core._utils.cuda_utils import CUDAError, driver, handle_return +from cuda.core._utils.version import binding_version, driver_version +from cuda.core.graph import GraphDefinition from cuda.core.typing import WorkqueueSharingScopeType # --------------------------------------------------------------------------- @@ -160,6 +162,38 @@ def _use_green_ctx(dev, ctx): dev.set_current(prev) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_memory_node_updates_preserve_green_context( + init_cuda, + green_ctx, +): + if driver_version() < (13, 2, 0) or binding_version() < (13, 2, 0): + pytest.skip("generic graph node parameter queries require CUDA 13.2+") + + memory_resource = LegacyPinnedMemoryResource() + src = memory_resource.allocate(4) + dst = memory_resource.allocate(4) + with _use_green_ctx(init_cuda, green_ctx): + graph_def = GraphDefinition() + memset_node = graph_def.memset(dst, 0, 4) + memcpy_node = graph_def.memcpy(dst, src, 4) + original_memset = handle_return(driver.cuGraphNodeGetParams(memset_node.handle)) + original_memcpy = handle_return(driver.cuGraphNodeGetParams(memcpy_node.handle)) + + memset_node.update(value=1) + memcpy_node.update(size=2) + updated_memset = handle_return(driver.cuGraphNodeGetParams(memset_node.handle)) + updated_memcpy = handle_return(driver.cuGraphNodeGetParams(memcpy_node.handle)) + + assert int(updated_memset.memset.ctx) == int(original_memset.memset.ctx) + assert int(updated_memcpy.memcpy.copyCtx) == int(original_memcpy.memcpy.copyCtx) + + memset_node.destroy() + memcpy_node.destroy() + src.close() + dst.close() + + # --------------------------------------------------------------------------- # Construction / type tests # --------------------------------------------------------------------------- From 88e3df2f1cdf5dc0ce86a3b1664f5e8ceed5473d Mon Sep 17 00:00:00 2001 From: Aryan Putta Date: Thu, 30 Jul 2026 23:43:31 -0400 Subject: [PATCH 12/50] docs(core): drop incorrect handle_type requirement for cuMemRetainAllocationHandle (#2418) Defect 4 of #2388. Signed-off-by: Aryan --- cuda_core/cuda/core/_memory/_virtual_memory_resource.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/cuda_core/cuda/core/_memory/_virtual_memory_resource.py b/cuda_core/cuda/core/_memory/_virtual_memory_resource.py index f30e6e3838d..74f0f347769 100644 --- a/cuda_core/cuda/core/_memory/_virtual_memory_resource.py +++ b/cuda_core/cuda/core/_memory/_virtual_memory_resource.py @@ -46,10 +46,9 @@ class VirtualMemoryResourceOptions: location_type: :obj:`~_memory.VirtualMemoryLocationType` | str Controls the location of the allocation. handle_type: :obj:`~_memory.VirtualMemoryHandleType` | str - Export handle type for the physical allocation. Use - ``"posix_fd"`` on Linux if you plan to - import/export the allocation (required for cuMemRetainAllocationHandle). - Use `None` if you don't need an exportable handle. + Export handle type for the physical allocation. Use ``"posix_fd"`` on + Linux if you plan to import/export the allocation. Use `None` if you + don't need an exportable handle. gpu_direct_rdma: bool Hint that the allocation should be GDR-capable (if supported). granularity: :obj:`~_memory.VirtualMemoryGranularityType` | str From 755cf61fb576c730d191ff2faab46b66926ce017 Mon Sep 17 00:00:00 2001 From: Sebastian Berg Date: Fri, 31 Jul 2026 16:26:49 +0200 Subject: [PATCH 13/50] Add identity preserving pattern to critical_sections (#2453) * Add identity preserving pattern to critical_sections this is annoying, but at least the library and probably kernel attributes should be idempotent. But critical sections *can and will be* released (similar to the GIL although not sure what is more likely). The important thing to note here is that the final attribute setting section is self-contained and holds the lock (even if another thread may have already set the attribute or still be executing the code above). * Use call-once pattern for module loading as double-load is problematic As per review by Keith * Minimal thread-unsafe initialization order fixes --- cuda_core/cuda/core/_linker.pyx | 2 +- cuda_core/cuda/core/_memory/_buffer.pyx | 5 +- cuda_core/cuda/core/_memory/_memory_pool.pyx | 5 +- cuda_core/cuda/core/_memoryview.pyx | 24 ++++++--- cuda_core/cuda/core/_module.pxd | 3 ++ cuda_core/cuda/core/_module.pyx | 56 ++++++++++++-------- cuda_core/cuda/core/_program.pyx | 10 ++-- 7 files changed, 69 insertions(+), 36 deletions(-) diff --git a/cuda_core/cuda/core/_linker.pyx b/cuda_core/cuda/core/_linker.pyx index 39b1f010a9e..2f4d8efd3a7 100644 --- a/cuda_core/cuda/core/_linker.pyx +++ b/cuda_core/cuda/core/_linker.pyx @@ -701,8 +701,8 @@ def _decide_nvjitlink_or_driver() -> bool: ) warn(warn_txt, stacklevel=2, category=RuntimeWarning) - _use_nvjitlink_backend = False _driver = driver + _use_nvjitlink_backend = False return True diff --git a/cuda_core/cuda/core/_memory/_buffer.pyx b/cuda_core/cuda/core/_memory/_buffer.pyx index d5ecac6cc09..2506331d0fd 100644 --- a/cuda_core/cuda/core/_memory/_buffer.pyx +++ b/cuda_core/cuda/core/_memory/_buffer.pyx @@ -272,8 +272,11 @@ cdef class Buffer: @cython.critical_section def ipc_descriptor(self) -> IPCBufferDescriptor: """Descriptor for sharing this buffer with other processes.""" + cdef object ipc_data if self._ipc_data is None: - self._ipc_data = IPCDataForBuffer(_ipc.Buffer_get_ipc_descriptor(self), False) + ipc_data = IPCDataForBuffer(_ipc.Buffer_get_ipc_descriptor(self), False) + if self._ipc_data is None: + self._ipc_data = ipc_data return self._ipc_data.ipc_descriptor def close(self, stream: Stream | GraphBuilder | None = None) -> None: diff --git a/cuda_core/cuda/core/_memory/_memory_pool.pyx b/cuda_core/cuda/core/_memory/_memory_pool.pyx index fbb320e02ff..8f9a4354b84 100644 --- a/cuda_core/cuda/core/_memory/_memory_pool.pyx +++ b/cuda_core/cuda/core/_memory/_memory_pool.pyx @@ -183,8 +183,11 @@ cdef class _MemPool(MemoryResource): @cython.critical_section def attributes(self) -> _MemPoolAttributes: """Memory pool attributes.""" + cdef _MemPoolAttributes attributes if self._attributes is None: - self._attributes = _MemPoolAttributes._init(self._h_pool) + attributes = _MemPoolAttributes._init(self._h_pool) + if self._attributes is None: + self._attributes = attributes return self._attributes @property diff --git a/cuda_core/cuda/core/_memoryview.pyx b/cuda_core/cuda/core/_memoryview.pyx index d6dd9bb2454..bbe5a887700 100644 --- a/cuda_core/cuda/core/_memoryview.pyx +++ b/cuda_core/cuda/core/_memoryview.pyx @@ -544,13 +544,16 @@ cdef class StridedMemoryView: @cython.critical_section cdef inline _StridedLayout get_layout(self): + cdef _StridedLayout layout if self._layout is None: if self.dl_tensor: - self._layout = layout_from_dlpack(self.dl_tensor) + layout = layout_from_dlpack(self.dl_tensor) elif self.metadata is not None: - self._layout = layout_from_cai(self.metadata) + layout = layout_from_cai(self.metadata) else: raise ValueError("Cannot infer layout from the exporting object") + if self._layout is None: + self._layout = layout return self._layout @cython.critical_section @@ -560,24 +563,31 @@ cdef class StridedMemoryView: If the SMV was created from a Buffer, it will return the same Buffer instance. Otherwise, it will create a new instance with owner set to the exporting object. """ + cdef object buffer if self._buffer is None: if isinstance(self.exporting_obj, Buffer): - self._buffer = self.exporting_obj + buffer = self.exporting_obj else: - self._buffer = Buffer.from_handle(self.ptr, 0, owner=self.exporting_obj) + buffer = Buffer.from_handle(self.ptr, 0, owner=self.exporting_obj) + if self._buffer is None: + self._buffer = buffer return self._buffer @cython.critical_section cdef inline object get_dtype(self): + cdef object dtype if self._dtype is None: + dtype = None if self.dl_tensor != NULL: - self._dtype = dtype_dlpack_to_numpy(&self.dl_tensor.dtype) + dtype = dtype_dlpack_to_numpy(&self.dl_tensor.dtype) elif isinstance(self.metadata, int): # AOTI dtype code stored by the torch tensor bridge - self._dtype = _get_tensor_bridge().resolve_aoti_dtype( + dtype = _get_tensor_bridge().resolve_aoti_dtype( self.metadata) elif self.metadata is not None: - self._dtype = _typestr2dtype(self.metadata["typestr"]) + dtype = _typestr2dtype(self.metadata["typestr"]) + if self._dtype is None: + self._dtype = dtype return self._dtype diff --git a/cuda_core/cuda/core/_module.pxd b/cuda_core/cuda/core/_module.pxd index 78f871b5ba2..5e9d08fc13f 100644 --- a/cuda_core/cuda/core/_module.pxd +++ b/cuda_core/cuda/core/_module.pxd @@ -2,6 +2,8 @@ # # SPDX-License-Identifier: Apache-2.0 +from libcpp.mutex cimport py_safe_once_flag + from cuda.bindings cimport cydriver from cuda.core._resource_handles cimport LibraryHandle, KernelHandle @@ -32,6 +34,7 @@ cdef class ObjectCode: object _module # bytes/str source dict _sym_map str _name + py_safe_once_flag _load_once object __weakref__ cdef int _lazy_load_module(self) except -1 diff --git a/cuda_core/cuda/core/_module.pyx b/cuda_core/cuda/core/_module.pyx index 5734e31414b..704f6d2f856 100644 --- a/cuda_core/cuda/core/_module.pyx +++ b/cuda_core/cuda/core/_module.pyx @@ -7,6 +7,7 @@ from __future__ import annotations cimport cython from libc.stddef cimport size_t from libc.stdint cimport intptr_t +from libcpp.mutex cimport py_safe_call_once from collections import namedtuple from os import fsencode, fspath, PathLike @@ -459,8 +460,11 @@ cdef class Kernel: @cython.critical_section def attributes(self) -> KernelAttributes: """Get the read-only attributes of this kernel.""" + cdef KernelAttributes attributes if self._attributes is None: - self._attributes = KernelAttributes._init(self._h_kernel) + attributes = KernelAttributes._init(self._h_kernel) + if self._attributes is None: + self._attributes = attributes return self._attributes cdef tuple _get_arguments_info(self, bint param_info=False): @@ -507,8 +511,11 @@ cdef class Kernel: @cython.critical_section def occupancy(self) -> KernelOccupancy: """Get the occupancy information for launching this kernel.""" + cdef KernelOccupancy occupancy if self._occupancy is None: - self._occupancy = KernelOccupancy._init(self._h_kernel) + occupancy = KernelOccupancy._init(self._h_kernel) + if self._occupancy is None: + self._occupancy = occupancy return self._occupancy @property @@ -584,6 +591,31 @@ CodeTypeT = bytes | bytearray | str cdef tuple _supported_code_type = tuple(ObjectCodeFormatType.__members__.values()) + +cdef void _lazy_load_module_once(void *self_v) except *: + # Call-once helper for the lazy module loading, we want to avoid unloading + # a module in case of threads racing, so use `call_once`. + cdef ObjectCode self = self_v + cdef LibraryHandle h_library + cdef bytes path_bytes + module = self._module + if isinstance(module, str): + path_bytes = module.encode() + h_library = create_library_handle_from_file(path_bytes) + elif isinstance(module, (bytes, bytearray)): + h_library = create_library_handle_from_data(module) + elif isinstance(module, PathLike): + path_bytes = fsencode(module) + h_library = create_library_handle_from_file(path_bytes) + else: + assert_type_str_or_bytes_like(module) + raise_code_path_meant_to_be_unreachable() + return + if not h_library: + HANDLE_RETURN(get_last_error()) + self._h_library = h_library + + cdef class ObjectCode: """Represent a compiled program to be loaded onto the device. @@ -746,26 +778,8 @@ cdef class ObjectCode: # TODO: do we want to unload in a finalizer? Probably not.. - @cython.critical_section cdef int _lazy_load_module(self) except -1: - if self._h_library: - return 0 - module = self._module - cdef bytes path_bytes - if isinstance(module, str): - path_bytes = module.encode() - self._h_library = create_library_handle_from_file(path_bytes) - elif isinstance(module, (bytes, bytearray)): - self._h_library = create_library_handle_from_data(module) - elif isinstance(module, PathLike): - path_bytes = fsencode(module) - self._h_library = create_library_handle_from_file(path_bytes) - else: - assert_type_str_or_bytes_like(module) - raise_code_path_meant_to_be_unreachable() - return -1 - if not self._h_library: - HANDLE_RETURN(get_last_error()) + py_safe_call_once(self._load_once, _lazy_load_module_once, self) return 0 def get_kernel(self, name: str | bytes) -> Kernel: diff --git a/cuda_core/cuda/core/_program.pyx b/cuda_core/cuda/core/_program.pyx index 2b2e5262a2c..27b1e5aa914 100644 --- a/cuda_core/cuda/core/_program.pyx +++ b/cuda_core/cuda/core/_program.pyx @@ -649,12 +649,10 @@ def _get_nvvm_module() -> object: """Get the NVVM module, importing it lazily with availability checks.""" global _nvvm_module, _nvvm_import_attempted - if _nvvm_import_attempted: - if _nvvm_module is None: - raise RuntimeError("NVVM module is not available (previous import attempt failed)") + if _nvvm_module is not None: return _nvvm_module - - _nvvm_import_attempted = True + if _nvvm_import_attempted: + raise RuntimeError("NVVM module is not available (previous import attempt failed)") try: version = binding_version() @@ -678,8 +676,10 @@ def _get_nvvm_module() -> object: except RuntimeError: _nvvm_module = None + _nvvm_import_attempted = True raise + def _find_libdevice_path() -> object: """Find libdevice*.bc for NVVM compilation using cuda.pathfinder.""" from cuda.pathfinder import find_bitcode_lib From 21286b0dabfab96bb06d199891936fecba331dae Mon Sep 17 00:00:00 2001 From: Michael Wang <13521008+isVoid@users.noreply.github.com> Date: Fri, 31 Jul 2026 09:39:53 -0700 Subject: [PATCH 14/50] Make Windows pathfinder dynamic library searches architecture-aware (#2393) * Make Windows pathfinder searches architecture-aware * Avoid Windows architecture detection on Linux * Rename unsupported architecture error * Skip CUDA 12 wheel paths on Windows ARM64 * Restore ARM64 cudla CTK search path * Group Windows search paths by architecture * Add architecture-specific Windows path tables * Make Windows CTK libnames architecture-aware * Add Windows architecture availability helper * Correct cuSPARSELt Windows ARM64 wheel path * Correct Windows CTK NVVM and CUPTI paths * Validate Windows NVVM binary architecture * Remove Windows architecture availability helper * Remove site-package catalog generation tool * Move pathfinder changes to 1.6.1 release notes * Remove pathfinder catalog generation tools * Restore site-packages collection scripts * Use platform-specific supported library names * Regenerate pathfinder 1.6.1 release notes * Remove redundant Windows libname consistency test * Mark agent-authored pathfinder tests * Clarify Windows binary architecture validation * Use all available dynamic library names * Test Windows site-package libraries by architecture * Require exactly one Windows architecture flag --------- Co-authored-by: Michael Wang Co-authored-by: Ralf W. Grosse-Kunstleve --- cuda_pathfinder/cuda/pathfinder/__init__.py | 10 +- .../_dynamic_libs/descriptor_catalog.py | 179 +++++++--- .../_dynamic_libs/load_nvidia_dynamic_lib.py | 8 +- .../_dynamic_libs/search_platform.py | 45 ++- .../pathfinder/_dynamic_libs/search_steps.py | 5 +- .../_dynamic_libs/supported_nvidia_libs.py | 59 +++- .../cuda/pathfinder/_utils/platform_aware.py | 12 + .../cuda/pathfinder/_utils/windows_arch.py | 65 ++++ cuda_pathfinder/docs/source/api.rst | 1 + .../docs/source/release/1.6.1-notes.rst | 38 +++ .../tests/test_ctk_root_discovery.py | 35 +- .../tests/test_descriptor_catalog.py | 41 ++- cuda_pathfinder/tests/test_lib_descriptor.py | 55 ++- .../tests/test_load_nvidia_dynamic_lib.py | 39 ++- cuda_pathfinder/tests/test_search_steps.py | 320 +++++++++++++++++- toolshed/_catalog_writer.py | 182 ---------- toolshed/build_pathfinder_dlls.py | 118 ------- toolshed/build_pathfinder_sonames.py | 93 ----- toolshed/collect_site_packages_dll_files.ps1 | 3 +- toolshed/collect_site_packages_so_files.sh | 3 +- toolshed/make_site_packages_libdirs.py | 123 ------- toolshed/update_catalog.py | 47 --- 22 files changed, 815 insertions(+), 666 deletions(-) create mode 100644 cuda_pathfinder/cuda/pathfinder/_utils/windows_arch.py create mode 100644 cuda_pathfinder/docs/source/release/1.6.1-notes.rst delete mode 100644 toolshed/_catalog_writer.py delete mode 100755 toolshed/build_pathfinder_dlls.py delete mode 100755 toolshed/build_pathfinder_sonames.py delete mode 100755 toolshed/make_site_packages_libdirs.py delete mode 100644 toolshed/update_catalog.py diff --git a/cuda_pathfinder/cuda/pathfinder/__init__.py b/cuda_pathfinder/cuda/pathfinder/__init__.py index dc818dfd08f..a64b5ef64c7 100644 --- a/cuda_pathfinder/cuda/pathfinder/__init__.py +++ b/cuda_pathfinder/cuda/pathfinder/__init__.py @@ -20,9 +20,7 @@ ) from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL as LoadedDL from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import load_nvidia_dynamic_lib as load_nvidia_dynamic_lib -from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import ( - SUPPORTED_LIBNAMES as SUPPORTED_NVIDIA_LIBNAMES, -) +from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import SUPPORTED_LIBNAMES as _SUPPORTED_NVIDIA_LIBNAMES from cuda.pathfinder._headers.find_nvidia_headers import LocatedHeaderDir as LocatedHeaderDir from cuda.pathfinder._headers.find_nvidia_headers import find_nvidia_header_directory as find_nvidia_header_directory from cuda.pathfinder._headers.find_nvidia_headers import ( @@ -60,6 +58,7 @@ locate_static_lib as locate_static_lib, ) from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home as get_cuda_path_or_home +from cuda.pathfinder._utils.windows_arch import UnsupportedArchError as UnsupportedArchError from cuda.pathfinder._version import __version__ # isort: skip @@ -76,6 +75,11 @@ #: Example utilities: ``"nvdisasm"``, ``"cuobjdump"``, ``"nvcc"``. SUPPORTED_BINARY_UTILITIES = _SUPPORTED_BINARIES +#: Tuple of CUDA Toolkit dynamic library names supported by +#: :func:`load_nvidia_dynamic_lib` for the current operating system and +#: interpreter architecture. +SUPPORTED_NVIDIA_LIBNAMES = _SUPPORTED_NVIDIA_LIBNAMES + #: Tuple of supported bitcode library names that can be resolved #: via ``locate_bitcode_lib()`` and ``find_bitcode_lib()``. #: Example value: ``"device"``. diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py index a26862c5435..e39046eec70 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py @@ -6,11 +6,53 @@ from __future__ import annotations from dataclasses import dataclass +from pathlib import PurePosixPath from typing import Literal from cuda.pathfinder._utils.ctk_root_canary import CTK_ROOT_CANARY_ANCHOR_LIBNAMES PackagedWith = Literal["ctk", "other", "driver"] +WindowsArch = Literal["x64", "arm64"] + + +@dataclass(frozen=True, slots=True) +class WindowsSearchDirs: + """Ordered Windows search locations grouped by process architecture.""" + + x64: tuple[str, ...] = () + arm64: tuple[str, ...] = () + + @classmethod + def x64_only(cls, *paths: str) -> WindowsSearchDirs: + return cls(x64=paths) + + @classmethod + def arm64_only(cls, *paths: str) -> WindowsSearchDirs: + return cls(arm64=paths) + + def for_arch(self, target_arch: str) -> tuple[str, ...]: + if target_arch == "x64": + return self.x64 + if target_arch == "arm64": + return self.arm64 + raise ValueError(f"Unsupported Windows target architecture: {target_arch!r}") + + +# Windows CTK before 13.4 was x64-only and used the common bin directory. +# Native ARM64 support starts with the architecture-qualified 13.4 layout. +DEFAULT_WINDOWS_CTK_ANCHOR_DIRS = WindowsSearchDirs( + x64=("bin/x64", "bin"), + arm64=("bin/arm64",), +) + + +def _ctk_windows_wheel_dirs(cuda13_bin_dir: str, cuda12_dir: str) -> WindowsSearchDirs: + """Search CUDA 13 first, with the x64-only CUDA 12 wheel as an x64 fallback.""" + cuda13_bin_path = PurePosixPath(cuda13_bin_dir) + return WindowsSearchDirs( + x64=((cuda13_bin_path / "x86_64").as_posix(), cuda12_dir), + arm64=((cuda13_bin_path / "arm64").as_posix(),), + ) @dataclass(frozen=True, slots=True) @@ -19,14 +61,16 @@ class DescriptorSpec: packaged_with: PackagedWith linux_sonames: tuple[str, ...] = () windows_dlls: tuple[str, ...] = () + supported_windows_arch: tuple[WindowsArch, ...] = () site_packages_linux: tuple[str, ...] = () - site_packages_windows: tuple[str, ...] = () + site_packages_windows: WindowsSearchDirs = WindowsSearchDirs() dependencies: tuple[str, ...] = () anchor_rel_dirs_linux: tuple[str, ...] = ("lib64", "lib") - anchor_rel_dirs_windows: tuple[str, ...] = ("bin/x64", "bin") + anchor_rel_dirs_windows: WindowsSearchDirs = DEFAULT_WINDOWS_CTK_ANCHOR_DIRS ctk_root_canary_anchor_libnames: tuple[str, ...] = () requires_add_dll_directory: bool = False requires_rtld_deepbind: bool = False + requires_windows_binary_arch_check: bool = False DESCRIPTOR_CATALOG: tuple[DescriptorSpec, ...] = ( @@ -38,32 +82,36 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libcudart.so.12", "libcudart.so.13"), windows_dlls=("cudart64_12.dll", "cudart64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cuda_runtime/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cuda_runtime/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cuda_runtime/bin"), ), DescriptorSpec( name="nvfatbin", packaged_with="ctk", linux_sonames=("libnvfatbin.so.12", "libnvfatbin.so.13"), windows_dlls=("nvfatbin_120_0.dll", "nvfatbin_130_0.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/nvfatbin/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/nvfatbin/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/nvfatbin/bin"), ), DescriptorSpec( name="nvJitLink", packaged_with="ctk", linux_sonames=("libnvJitLink.so.12", "libnvJitLink.so.13"), windows_dlls=("nvJitLink_120_0.dll", "nvJitLink_130_0.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/nvjitlink/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/nvjitlink/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/nvjitlink/bin"), ), DescriptorSpec( name="nvrtc", packaged_with="ctk", linux_sonames=("libnvrtc.so.12", "libnvrtc.so.13"), windows_dlls=("nvrtc64_120_0.dll", "nvrtc64_130_0.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cuda_nvrtc/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cuda_nvrtc/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cuda_nvrtc/bin"), requires_add_dll_directory=True, ), DescriptorSpec( @@ -71,19 +119,31 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnvvm.so.4",), windows_dlls=("nvvm64.dll", "nvvm64_40_0.dll", "nvvm70.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cuda_nvcc/nvvm/lib64"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cuda_nvcc/nvvm/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cuda_nvcc/nvvm/bin"), anchor_rel_dirs_linux=("nvvm/lib64",), - anchor_rel_dirs_windows=("nvvm/bin/*", "nvvm/bin"), + # CTK 13.4 installs the ARM64 DLL directly in nvvm/bin, while x64 + # uses nvvm/bin/x64. Older x64 toolkits also used nvvm/bin, so the + # binary in the unqualified directory must be checked at runtime. + anchor_rel_dirs_windows=WindowsSearchDirs( + x64=("nvvm/bin/x64", "nvvm/bin"), + arm64=("nvvm/bin",), + ), ctk_root_canary_anchor_libnames=CTK_ROOT_CANARY_ANCHOR_LIBNAMES, + # requires_windows_binary_arch_check disambiguates pre-13.4 x64 DLLs + # from 13.4+ Arm64 DLLs in nvvm/bin; see + # _utils/windows_arch.py for the validation. + requires_windows_binary_arch_check=True, ), DescriptorSpec( name="cublas", packaged_with="ctk", linux_sonames=("libcublas.so.12", "libcublas.so.13"), windows_dlls=("cublas64_12.dll", "cublas64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cublas/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cublas/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cublas/bin"), dependencies=("cublasLt",), ), DescriptorSpec( @@ -91,16 +151,18 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libcublasLt.so.12", "libcublasLt.so.13"), windows_dlls=("cublasLt64_12.dll", "cublasLt64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cublas/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cublas/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cublas/bin"), ), DescriptorSpec( name="cufft", packaged_with="ctk", linux_sonames=("libcufft.so.11", "libcufft.so.12"), windows_dlls=("cufft64_11.dll", "cufft64_12.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cufft/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cufft/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cufft/bin"), requires_add_dll_directory=True, ), DescriptorSpec( @@ -108,8 +170,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libcufftw.so.11", "libcufftw.so.12"), windows_dlls=("cufftw64_11.dll", "cufftw64_12.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cufft/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cufft/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cufft/bin"), dependencies=("cufft",), ), DescriptorSpec( @@ -117,16 +180,18 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libcurand.so.10",), windows_dlls=("curand64_10.dll",), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/curand/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/curand/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/curand/bin"), ), DescriptorSpec( name="cusolver", packaged_with="ctk", linux_sonames=("libcusolver.so.11", "libcusolver.so.12"), windows_dlls=("cusolver64_11.dll", "cusolver64_12.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cusolver/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cusolver/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cusolver/bin"), dependencies=("nvJitLink", "cusparse", "cublasLt", "cublas"), ), DescriptorSpec( @@ -134,8 +199,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libcusolverMg.so.11", "libcusolverMg.so.12"), windows_dlls=("cusolverMg64_11.dll", "cusolverMg64_12.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cusolver/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cusolver/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cusolver/bin"), dependencies=("nvJitLink", "cublasLt", "cublas"), ), DescriptorSpec( @@ -143,8 +209,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libcusparse.so.12",), windows_dlls=("cusparse64_12.dll",), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cusparse/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cusparse/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cusparse/bin"), dependencies=("nvJitLink",), ), DescriptorSpec( @@ -152,16 +219,18 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppc.so.12", "libnppc.so.13"), windows_dlls=("nppc64_12.dll", "nppc64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), ), DescriptorSpec( name="nppial", packaged_with="ctk", linux_sonames=("libnppial.so.12", "libnppial.so.13"), windows_dlls=("nppial64_12.dll", "nppial64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -169,8 +238,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppicc.so.12", "libnppicc.so.13"), windows_dlls=("nppicc64_12.dll", "nppicc64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -178,8 +248,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppidei.so.12", "libnppidei.so.13"), windows_dlls=("nppidei64_12.dll", "nppidei64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -187,8 +258,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppif.so.12", "libnppif.so.13"), windows_dlls=("nppif64_12.dll", "nppif64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -196,8 +268,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppig.so.12", "libnppig.so.13"), windows_dlls=("nppig64_12.dll", "nppig64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -205,8 +278,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppim.so.12", "libnppim.so.13"), windows_dlls=("nppim64_12.dll", "nppim64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -214,8 +288,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppist.so.12", "libnppist.so.13"), windows_dlls=("nppist64_12.dll", "nppist64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -223,8 +298,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppisu.so.12", "libnppisu.so.13"), windows_dlls=("nppisu64_12.dll", "nppisu64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -232,8 +308,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnppitc.so.12", "libnppitc.so.13"), windows_dlls=("nppitc64_12.dll", "nppitc64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -241,8 +318,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnpps.so.12", "libnpps.so.13"), windows_dlls=("npps64_12.dll", "npps64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/npp/bin"), dependencies=("nppc",), ), DescriptorSpec( @@ -250,8 +328,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnvblas.so.12", "libnvblas.so.13"), windows_dlls=("nvblas64_12.dll", "nvblas64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cublas/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cublas/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cublas/bin"), dependencies=("cublas", "cublasLt"), ), DescriptorSpec( @@ -259,8 +338,9 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libnvjpeg.so.12", "libnvjpeg.so.13"), windows_dlls=("nvjpeg64_12.dll", "nvjpeg64_13.dll"), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/nvjpeg/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/nvjpeg/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/nvjpeg/bin"), ), DescriptorSpec( name="cufile", @@ -290,10 +370,16 @@ class DescriptorSpec: "cupti64_2023.1.1.dll", "cupti64_2022.4.1.dll", ), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cuda_cupti/lib"), - site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cuda_cupti/bin"), + site_packages_windows=_ctk_windows_wheel_dirs("nvidia/cu13/bin", "nvidia/cuda_cupti/bin"), anchor_rel_dirs_linux=("extras/CUPTI/lib64", "lib"), - anchor_rel_dirs_windows=("extras/CUPTI/lib64", "bin"), + # CTK 13.4 uses architecture-qualified CUPTI directories. Older + # Windows CUPTI toolkits were x64-only and used extras/CUPTI/lib64. + anchor_rel_dirs_windows=WindowsSearchDirs( + x64=("extras/CUPTI/lib/x64", "extras/CUPTI/lib64", "bin"), + arm64=("extras/CUPTI/lib/arm64",), + ), ctk_root_canary_anchor_libnames=CTK_ROOT_CANARY_ANCHOR_LIBNAMES, ), DescriptorSpec( @@ -301,12 +387,11 @@ class DescriptorSpec: packaged_with="ctk", linux_sonames=("libcudla.so.1",), windows_dlls=("cudla.dll",), + supported_windows_arch=("arm64",), site_packages_linux=("nvidia/cu13/lib",), # No Windows pip wheel ships cudla.dll today; it is loaded from the local # CUDA Toolkit only, so site_packages_windows is intentionally left empty. - # The Windows CUDA Toolkit ships cudla.dll under per-architecture bin - # subdirs (e.g. bin/arm64 on N1X); search those ahead of the defaults. - anchor_rel_dirs_windows=("bin/arm64", "bin/x64", "bin"), + anchor_rel_dirs_windows=WindowsSearchDirs.arm64_only("bin/arm64"), ), # ----------------------------------------------------------------------- # Third-party / separately packaged libraries @@ -338,8 +423,12 @@ class DescriptorSpec: packaged_with="other", linux_sonames=("libmathdx.so.0",), windows_dlls=("mathdx64_0.dll",), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cu12/lib"), - site_packages_windows=("nvidia/cu13/bin", "nvidia/cu12/bin"), + site_packages_windows=WindowsSearchDirs( + x64=("nvidia/cu13/bin", "nvidia/cu12/bin"), + arm64=("nvidia/cu13/bin", "nvidia/cu12/bin"), + ), dependencies=("nvrtc",), ), DescriptorSpec( @@ -347,8 +436,12 @@ class DescriptorSpec: packaged_with="other", linux_sonames=("libcudss.so.0",), windows_dlls=("cudss64_0.dll",), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cu12/lib"), - site_packages_windows=("nvidia/cu13/bin", "nvidia/cu12/bin"), + site_packages_windows=WindowsSearchDirs( + x64=("nvidia/cu13/bin", "nvidia/cu12/bin"), + arm64=("nvidia/cu13/bin", "nvidia/cu12/bin"), + ), dependencies=("cublas", "cublasLt"), ), DescriptorSpec( @@ -356,16 +449,21 @@ class DescriptorSpec: packaged_with="other", linux_sonames=("libcusparseLt.so.0",), windows_dlls=("cusparseLt.dll",), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("nvidia/cu13/lib", "nvidia/cusparselt/lib"), - site_packages_windows=("nvidia/cu13/bin/x64", "nvidia/cusparselt/bin"), + site_packages_windows=WindowsSearchDirs( + x64=("nvidia/cu13/bin/x64", "nvidia/cusparselt/bin"), + arm64=("nvidia/cu13/bin/arm64",), + ), ), DescriptorSpec( name="cutensor", packaged_with="other", linux_sonames=("libcutensor.so.2",), windows_dlls=("cutensor.dll",), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("cutensor/lib",), - site_packages_windows=("cutensor/bin",), + site_packages_windows=WindowsSearchDirs(x64=("cutensor/bin",), arm64=("cutensor/bin",)), dependencies=("cublasLt",), ), DescriptorSpec( @@ -373,8 +471,9 @@ class DescriptorSpec: packaged_with="other", linux_sonames=("libcutensorMg.so.2",), windows_dlls=("cutensorMg.dll",), + supported_windows_arch=("x64", "arm64"), site_packages_linux=("cutensor/lib",), - site_packages_windows=("cutensor/bin",), + site_packages_windows=WindowsSearchDirs(x64=("cutensor/bin",), arm64=("cutensor/bin",)), dependencies=("cutensor", "cublasLt"), ), DescriptorSpec( @@ -452,6 +551,7 @@ class DescriptorSpec: packaged_with="driver", linux_sonames=("libcuda.so.1",), windows_dlls=("nvcuda.dll",), + supported_windows_arch=("x64", "arm64"), ), DescriptorSpec( name="nvcudla", @@ -463,5 +563,6 @@ class DescriptorSpec: packaged_with="driver", linux_sonames=("libnvidia-ml.so.1",), windows_dlls=("nvml.dll",), + supported_windows_arch=("x64", "arm64"), ), ) diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py index 95a71825793..53446107da3 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py @@ -34,6 +34,7 @@ build_dynamic_lib_subprocess_command, parse_dynamic_lib_subprocess_payload, ) +from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import ALL_AVAILABLE_LIBNAMES from cuda.pathfinder._utils.platform_aware import IS_WINDOWS if TYPE_CHECKING: @@ -42,9 +43,6 @@ # All libnames recognized by load_nvidia_dynamic_lib, across all categories # (CTK, third-party, driver). _ALL_KNOWN_LIBNAMES: frozenset[str] = frozenset(LIB_DESCRIPTORS) -_ALL_SUPPORTED_LIBNAMES: frozenset[str] = frozenset( - name for name, desc in LIB_DESCRIPTORS.items() if (desc.windows_dlls if IS_WINDOWS else desc.linux_sonames) -) _PLATFORM_NAME = "Windows" if IS_WINDOWS else "Linux" _CANARY_PROBE_TIMEOUT_SECONDS = 10.0 @@ -308,9 +306,9 @@ def load_nvidia_dynamic_lib(libname: str) -> LoadedDL: ) if libname not in _ALL_KNOWN_LIBNAMES: raise DynamicLibUnknownError(f"Unknown library name: {libname!r}. Known names: {sorted(_ALL_KNOWN_LIBNAMES)}") - if libname not in _ALL_SUPPORTED_LIBNAMES: + if libname not in ALL_AVAILABLE_LIBNAMES: raise DynamicLibNotAvailableError( f"Library name {libname!r} is known but not available on {_PLATFORM_NAME}. " - f"Supported names on {_PLATFORM_NAME}: {sorted(_ALL_SUPPORTED_LIBNAMES)}" + f"Supported names on {_PLATFORM_NAME}: {sorted(ALL_AVAILABLE_LIBNAMES)}" ) return _load_lib_no_cache(libname) diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/search_platform.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/search_platform.py index 37fd6eb1700..2d6a5f016a7 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/search_platform.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/search_platform.py @@ -14,12 +14,14 @@ import os from collections.abc import Sequence from dataclasses import dataclass +from pathlib import PurePath from typing import Protocol, cast from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import is_suppressed_dll_file from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages from cuda.pathfinder._utils.platform_aware import IS_WINDOWS +from cuda.pathfinder._utils.windows_arch import windows_pe_matches_arch, windows_python_arch def _no_such_file_in_sub_dirs( @@ -41,7 +43,7 @@ def _find_so_in_rel_dirs( sub_dirs_searched: list[tuple[str, ...]] = [] file_wild = so_basename + "*" for rel_dir in rel_dirs: - sub_dir = tuple(rel_dir.split(os.path.sep)) + sub_dir = PurePath(rel_dir).parts for abs_dir in find_sub_dirs_all_sitepackages(sub_dir): # Exact unversioned match first; fall back to versioned names because some # distros only ship lib.so. (e.g. conda libcupti). Only one match @@ -61,12 +63,15 @@ def _find_so_in_rel_dirs( return None -def _find_dll_under_dir(dirpath: str, file_wild: str) -> str | None: +def _find_dll_under_dir(dirpath: str, file_wild: str, target_arch: str | None = None) -> str | None: for path in sorted(glob.glob(os.path.join(dirpath, file_wild))): if not os.path.isfile(path): continue - if not is_suppressed_dll_file(os.path.basename(path)): - return path + if is_suppressed_dll_file(os.path.basename(path)): + continue + if target_arch is not None and not windows_pe_matches_arch(path, target_arch): + continue + return path return None @@ -78,7 +83,7 @@ def _find_dll_in_rel_dirs( ) -> str | None: sub_dirs_searched: list[tuple[str, ...]] = [] for rel_dir in rel_dirs: - sub_dir = tuple(rel_dir.split(os.path.sep)) + sub_dir = PurePath(rel_dir).parts for abs_dir in find_sub_dirs_all_sitepackages(sub_dir): dll_name = _find_dll_under_dir(abs_dir, lib_searched_for) if dll_name is not None: @@ -109,7 +114,7 @@ def find_in_site_packages( def find_in_lib_dir( self, lib_dir: str, - libname: str, + desc: LibDescriptor, lib_searched_for: str, error_messages: list[str], attachments: list[str], @@ -142,7 +147,7 @@ def find_in_site_packages( def find_in_lib_dir( self, lib_dir: str, - _libname: str, + _desc: LibDescriptor, lib_searched_for: str, error_messages: list[str], attachments: list[str], @@ -173,17 +178,19 @@ def find_in_lib_dir( @dataclass(frozen=True, slots=True) class WindowsSearchPlatform: + target_arch: str + def lib_searched_for(self, libname: str) -> str: return f"{libname}*.dll" def site_packages_rel_dirs(self, desc: LibDescriptor) -> tuple[str, ...]: - return cast(tuple[str, ...], desc.site_packages_windows) + return cast(tuple[str, ...], desc.site_packages_windows.for_arch(self.target_arch)) def conda_anchor_point(self, conda_prefix: str) -> str: return os.path.join(conda_prefix, "Library") def anchor_rel_dirs(self, desc: LibDescriptor) -> tuple[str, ...]: - return cast(tuple[str, ...], desc.anchor_rel_dirs_windows) + return cast(tuple[str, ...], desc.anchor_rel_dirs_windows.for_arch(self.target_arch)) def find_in_site_packages( self, @@ -197,16 +204,20 @@ def find_in_site_packages( def find_in_lib_dir( self, lib_dir: str, - libname: str, + desc: LibDescriptor, _lib_searched_for: str, error_messages: list[str], attachments: list[str], ) -> str | None: - file_wild = libname + "*.dll" - dll_name = _find_dll_under_dir(lib_dir, file_wild) + file_wild = desc.name + "*.dll" + target_arch = self.target_arch if desc.requires_windows_binary_arch_check else None + dll_name = _find_dll_under_dir(lib_dir, file_wild, target_arch) if dll_name is not None: return dll_name - error_messages.append(f"No such file: {file_wild}") + if target_arch is None: + error_messages.append(f"No such file: {file_wild}") + else: + error_messages.append(f"No {target_arch}-compatible PE file: {file_wild}") attachments.append(f' listdir("{lib_dir}"):') if not os.path.isdir(lib_dir): attachments.append(" DIRECTORY DOES NOT EXIST") @@ -216,4 +227,10 @@ def find_in_lib_dir( return None -PLATFORM: SearchPlatform = WindowsSearchPlatform() if IS_WINDOWS else LinuxSearchPlatform() +def _platform_for_current_system() -> SearchPlatform: + if IS_WINDOWS: + return WindowsSearchPlatform(target_arch=windows_python_arch()) + return LinuxSearchPlatform() + + +PLATFORM = _platform_for_current_system() diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/search_steps.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/search_steps.py index 55d8a8aa674..5901094fcaa 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/search_steps.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/search_steps.py @@ -88,7 +88,7 @@ def _find_using_lib_dir(ctx: SearchContext, lib_dir: str | None) -> str | None: str | None, ctx.platform.find_in_lib_dir( lib_dir, - ctx.libname, + ctx.desc, ctx.lib_searched_for, ctx.error_messages, ctx.attachments, @@ -121,13 +121,14 @@ def _derive_ctk_root_windows(resolved_lib_path: str) -> str | None: Supports: - ``$CTK_ROOT/bin/x64/foo.dll`` (CTK 13 style) + - ``$CTK_ROOT/bin/arm64/foo.dll`` (Windows on Arm CTK 13 style) - ``$CTK_ROOT/bin/foo.dll`` (CTK 12 style) """ import ntpath lib_dir = ntpath.dirname(resolved_lib_path) basename = ntpath.basename(lib_dir).lower() - if basename == "x64": + if basename in ("x64", "arm64"): parent = ntpath.dirname(lib_dir) if ntpath.basename(parent).lower() == "bin": return ntpath.dirname(parent) diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/supported_nvidia_libs.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/supported_nvidia_libs.py index db06411c6d0..daf696b638e 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/supported_nvidia_libs.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/supported_nvidia_libs.py @@ -6,12 +6,18 @@ The canonical data entry point is :mod:`descriptor_catalog`. This module keeps historical constant names for backward compatibility by deriving them from the catalog. + +The unsuffixed ``SUPPORTED_LIBNAMES_WINDOWS`` and +``SITE_PACKAGES_LIBDIRS_WINDOWS*`` constants retain their historical x64 +meaning for compatibility, but are not recommended for new code. Use the +explicit ``*_X64`` or ``*_ARM64`` projection instead. Never combine the two +architecture projections. """ from __future__ import annotations from cuda.pathfinder._dynamic_libs.descriptor_catalog import DESCRIPTOR_CATALOG -from cuda.pathfinder._utils.platform_aware import IS_WINDOWS +from cuda.pathfinder._utils.platform_aware import IS_WINDOWS, IS_WINDOWS_ARM64, IS_WINDOWS_X64 _CTK_DESCRIPTORS = tuple(desc for desc in DESCRIPTOR_CATALOG if desc.packaged_with == "ctk") _OTHER_DESCRIPTORS = tuple(desc for desc in DESCRIPTOR_CATALOG if desc.packaged_with == "other") @@ -26,10 +32,30 @@ desc.name for desc in _CTK_DESCRIPTORS if desc.windows_dlls and not desc.linux_sonames ) +if not IS_WINDOWS: + ALL_AVAILABLE_LIBNAMES = frozenset(desc.name for desc in DESCRIPTOR_CATALOG if desc.linux_sonames) +else: + assert IS_WINDOWS_X64 != IS_WINDOWS_ARM64 + _current_windows_arch = "x64" if IS_WINDOWS_X64 else "arm64" + ALL_AVAILABLE_LIBNAMES = frozenset( + desc.name for desc in DESCRIPTOR_CATALOG if _current_windows_arch in desc.supported_windows_arch + ) + SUPPORTED_LIBNAMES_LINUX = SUPPORTED_LIBNAMES_COMMON + SUPPORTED_LIBNAMES_LINUX_ONLY -SUPPORTED_LIBNAMES_WINDOWS = SUPPORTED_LIBNAMES_COMMON + SUPPORTED_LIBNAMES_WINDOWS_ONLY +SUPPORTED_LIBNAMES_WINDOWS_X64 = tuple(desc.name for desc in _CTK_DESCRIPTORS if "x64" in desc.supported_windows_arch) +SUPPORTED_LIBNAMES_WINDOWS_ARM64 = tuple( + desc.name for desc in _CTK_DESCRIPTORS if "arm64" in desc.supported_windows_arch +) +# Backward-compatible alias preserves the historical x64 meaning. +SUPPORTED_LIBNAMES_WINDOWS = SUPPORTED_LIBNAMES_WINDOWS_X64 SUPPORTED_LIBNAMES_ALL = SUPPORTED_LIBNAMES_COMMON + SUPPORTED_LIBNAMES_LINUX_ONLY + SUPPORTED_LIBNAMES_WINDOWS_ONLY -SUPPORTED_LIBNAMES = SUPPORTED_LIBNAMES_WINDOWS if IS_WINDOWS else SUPPORTED_LIBNAMES_LINUX +if not IS_WINDOWS: + SUPPORTED_LIBNAMES = SUPPORTED_LIBNAMES_LINUX +elif IS_WINDOWS_X64: + SUPPORTED_LIBNAMES = SUPPORTED_LIBNAMES_WINDOWS_X64 +else: + assert IS_WINDOWS_ARM64 + SUPPORTED_LIBNAMES = SUPPORTED_LIBNAMES_WINDOWS_ARM64 DIRECT_DEPENDENCIES_CTK = {desc.name: desc.dependencies for desc in _CTK_DESCRIPTORS if desc.dependencies} DIRECT_DEPENDENCIES = {desc.name: desc.dependencies for desc in DESCRIPTOR_CATALOG if desc.dependencies} @@ -51,7 +77,6 @@ desc.name for desc in DESCRIPTOR_CATALOG if desc.requires_rtld_deepbind and desc.linux_sonames ) -# Based on output of toolshed/make_site_packages_libdirs_linux.py SITE_PACKAGES_LIBDIRS_LINUX_CTK = { desc.name: desc.site_packages_linux for desc in _CTK_DESCRIPTORS if desc.site_packages_linux } @@ -60,13 +85,29 @@ } SITE_PACKAGES_LIBDIRS_LINUX = SITE_PACKAGES_LIBDIRS_LINUX_CTK | SITE_PACKAGES_LIBDIRS_LINUX_OTHER -SITE_PACKAGES_LIBDIRS_WINDOWS_CTK = { - desc.name: desc.site_packages_windows for desc in _CTK_DESCRIPTORS if desc.site_packages_windows +# Architecture-specific Windows projections. Keep these separate: combining +# them would make the table unsafe to consume for either process ABI. +SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_X64 = { + desc.name: desc.site_packages_windows.x64 for desc in _CTK_DESCRIPTORS if desc.site_packages_windows.x64 +} +SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_ARM64 = { + desc.name: desc.site_packages_windows.arm64 for desc in _CTK_DESCRIPTORS if desc.site_packages_windows.arm64 } -SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER = { - desc.name: desc.site_packages_windows for desc in _NON_CTK_DESCRIPTORS if desc.site_packages_windows +SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER_X64 = { + desc.name: desc.site_packages_windows.x64 for desc in _NON_CTK_DESCRIPTORS if desc.site_packages_windows.x64 } -SITE_PACKAGES_LIBDIRS_WINDOWS = SITE_PACKAGES_LIBDIRS_WINDOWS_CTK | SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER +SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER_ARM64 = { + desc.name: desc.site_packages_windows.arm64 for desc in _NON_CTK_DESCRIPTORS if desc.site_packages_windows.arm64 +} +SITE_PACKAGES_LIBDIRS_WINDOWS_X64 = SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_X64 | SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER_X64 +SITE_PACKAGES_LIBDIRS_WINDOWS_ARM64 = ( + SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_ARM64 | SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER_ARM64 +) + +# Backward-compatible aliases preserve the historical x64 meaning. +SITE_PACKAGES_LIBDIRS_WINDOWS_CTK = SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_X64 +SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER = SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER_X64 +SITE_PACKAGES_LIBDIRS_WINDOWS = SITE_PACKAGES_LIBDIRS_WINDOWS_X64 def is_suppressed_dll_file(path_basename: str) -> bool: diff --git a/cuda_pathfinder/cuda/pathfinder/_utils/platform_aware.py b/cuda_pathfinder/cuda/pathfinder/_utils/platform_aware.py index 72ecbc53593..af0610a6cdb 100644 --- a/cuda_pathfinder/cuda/pathfinder/_utils/platform_aware.py +++ b/cuda_pathfinder/cuda/pathfinder/_utils/platform_aware.py @@ -4,6 +4,18 @@ import sys IS_WINDOWS = sys.platform == "win32" +_WINDOWS_PYTHON_ARCH: str | None + +if IS_WINDOWS: + from cuda.pathfinder._utils.windows_arch import windows_python_arch + + _WINDOWS_PYTHON_ARCH = windows_python_arch() +else: + _WINDOWS_PYTHON_ARCH = None + +# These describe the Python process ABI, not the Windows host architecture. +IS_WINDOWS_X64 = _WINDOWS_PYTHON_ARCH == "x64" +IS_WINDOWS_ARM64 = _WINDOWS_PYTHON_ARCH == "arm64" def quote_for_shell(s: str) -> str: diff --git a/cuda_pathfinder/cuda/pathfinder/_utils/windows_arch.py b/cuda_pathfinder/cuda/pathfinder/_utils/windows_arch.py new file mode 100644 index 00000000000..9313f3a9f17 --- /dev/null +++ b/cuda_pathfinder/cuda/pathfinder/_utils/windows_arch.py @@ -0,0 +1,65 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import sysconfig + +WINDOWS_PE_MACHINE_BY_ARCH = { + "x64": 0x8664, + "arm64": 0xAA64, +} + + +class UnsupportedArchError(RuntimeError): + """Raised when Python reports an unsupported Windows architecture.""" + + def __init__(self, platform_tag: str) -> None: + self.platform_tag = platform_tag + super().__init__( + f"Unsupported Windows Python platform tag: {platform_tag!r}; expected 'win-amd64' or 'win-arm64'" + ) + + +def windows_python_arch() -> str: + """Return the current Windows Python interpreter architecture.""" + raw_platform_tag = sysconfig.get_platform() + platform_tag = raw_platform_tag.lower().replace("_", "-") + + if platform_tag == "win-arm64": + return "arm64" + + if platform_tag == "win-amd64": + return "x64" + + raise UnsupportedArchError(raw_platform_tag) + + +def windows_pe_matches_arch(path: str, target_arch: str) -> bool: + """Return whether a Windows Portable Executable (PE) targets the requested architecture. + + PE is the file format used for Windows executables and DLLs. This reads the + PE/COFF header's machine field to distinguish x64 images from Arm64 images. + """ + expected_machine = WINDOWS_PE_MACHINE_BY_ARCH.get(target_arch) + if expected_machine is None: + raise ValueError(f"Unsupported Windows target architecture: {target_arch!r}") + + try: + with open(path, "rb") as stream: + if stream.read(2) != b"MZ": + return False + stream.seek(0x3C) + pe_offset_bytes = stream.read(4) + if len(pe_offset_bytes) != 4: + return False + stream.seek(int.from_bytes(pe_offset_bytes, "little")) + if stream.read(4) != b"PE\0\0": + return False + machine_bytes = stream.read(2) + if len(machine_bytes) != 2: + return False + except OSError: + return False + + return int.from_bytes(machine_bytes, "little") == expected_machine diff --git a/cuda_pathfinder/docs/source/api.rst b/cuda_pathfinder/docs/source/api.rst index e49478c09ec..f65014923f9 100644 --- a/cuda_pathfinder/docs/source/api.rst +++ b/cuda_pathfinder/docs/source/api.rst @@ -24,6 +24,7 @@ CUDA bitcode and static libraries. DynamicLibNotFoundError DynamicLibUnknownError DynamicLibNotAvailableError + UnsupportedArchError SUPPORTED_HEADERS_CTK find_nvidia_header_directory diff --git a/cuda_pathfinder/docs/source/release/1.6.1-notes.rst b/cuda_pathfinder/docs/source/release/1.6.1-notes.rst new file mode 100644 index 00000000000..29a3106e0f1 --- /dev/null +++ b/cuda_pathfinder/docs/source/release/1.6.1-notes.rst @@ -0,0 +1,38 @@ +.. SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +.. SPDX-License-Identifier: Apache-2.0 + +.. py:currentmodule:: cuda.pathfinder + +``cuda-pathfinder`` 1.6.1 Release notes +======================================= + +Highlights +---------- + +* Make Windows dynamic-library discovery architecture-aware. Pathfinder now + detects whether the current Python interpreter is x64 or Arm64, searches + only the matching CUDA Toolkit and wheel directories, and reports only the + CTK libraries available for that architecture through + ``SUPPORTED_NVIDIA_LIBNAMES``. A known library unavailable for the current + architecture raises ``DynamicLibNotAvailableError``. + +* Add Windows Arm64 discovery for CUDA 13.4 layouts while retaining legacy + CUDA 12 wheel directories as x64-only fallbacks. This includes corrected + architecture-specific locations for cuDLA, NVVM, CUPTI, and cuSPARSELt. + NVVM binaries found in an unqualified legacy directory are checked for a + matching PE machine architecture before loading. + +* Add ``UnsupportedArchError`` for unsupported Windows Python platform tags. + +Internal maintenance +-------------------- + +* Group Windows search locations by architecture in the dynamic-library + descriptor catalog. Add explicit ``_X64`` and ``_ARM64`` variants of the + internal ``SUPPORTED_LIBNAMES_WINDOWS*`` and + ``SITE_PACKAGES_LIBDIRS_WINDOWS*`` tables. Unsuffixed names remain x64 + aliases for backward compatibility. + +* Remove the obsolete descriptor-catalog writer and its catalog-update tools. + The site-packages collection scripts remain available for gathering library + paths. diff --git a/cuda_pathfinder/tests/test_ctk_root_discovery.py b/cuda_pathfinder/tests/test_ctk_root_discovery.py index 9ad148dccd2..b4aa33d6a74 100644 --- a/cuda_pathfinder/tests/test_ctk_root_discovery.py +++ b/cuda_pathfinder/tests/test_ctk_root_discovery.py @@ -19,6 +19,7 @@ _try_ctk_root_canary, resolve_ctk_root_via_canary, ) +from cuda.pathfinder._dynamic_libs.search_platform import WindowsSearchPlatform from cuda.pathfinder._dynamic_libs.search_steps import ( SearchContext, _derive_ctk_root_linux, @@ -32,6 +33,7 @@ MODE_CANARY, ) from cuda.pathfinder._utils.platform_aware import IS_WINDOWS +from cuda.pathfinder._utils.windows_arch import windows_python_arch _MODULE = "cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib" _STEPS_MODULE = "cuda.pathfinder._dynamic_libs.search_steps" @@ -60,11 +62,18 @@ def _create_nvvm_in_ctk(ctk_root): nvvm_dir = ctk_root / "nvvm" / "bin" nvvm_dir.mkdir(parents=True) nvvm_lib = nvvm_dir / "nvvm64.dll" + machine = {"x64": 0x8664, "arm64": 0xAA64}[windows_python_arch()] + image = bytearray(0x86) + image[:2] = b"MZ" + image[0x3C:0x40] = (0x80).to_bytes(4, "little") + image[0x80:0x84] = b"PE\0\0" + image[0x84:0x86] = machine.to_bytes(2, "little") + nvvm_lib.write_bytes(image) else: nvvm_dir = ctk_root / "nvvm" / "lib64" nvvm_dir.mkdir(parents=True) nvvm_lib = nvvm_dir / "libnvvm.so" - nvvm_lib.write_bytes(b"fake") + nvvm_lib.write_bytes(b"fake") return nvvm_lib @@ -126,6 +135,12 @@ def test_derive_ctk_root_windows_ctk13(): assert _derive_ctk_root_windows(path) == r"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.0" +@pytest.mark.agent_authored(model="gpt-5") +def test_derive_ctk_root_windows_ctk13_arm64(): + path = r"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\bin\arm64\cudart64_13.dll" + assert _derive_ctk_root_windows(path) == r"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" + + def test_derive_ctk_root_windows_ctk12(): path = r"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.8\bin\cudart64_12.dll" assert _derive_ctk_root_windows(path) == r"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.8" @@ -190,6 +205,24 @@ def test_try_via_ctk_root_regular_lib(tmp_path): assert result.found_via == "system-ctk-root" +@pytest.mark.agent_authored(model="gpt-5") +def test_try_via_ctk_root_windows_arm64_prefers_arch_dir(tmp_path): + ctk_root = tmp_path / "cuda-13" + x64_dir = ctk_root / "bin" / "x64" + arm64_dir = ctk_root / "bin" / "arm64" + x64_dir.mkdir(parents=True) + arm64_dir.mkdir(parents=True) + (x64_dir / "cudart64_13.dll").write_bytes(b"fake") + arm64_lib = arm64_dir / "cudart64_13.dll" + arm64_lib.write_bytes(b"fake") + + ctx = SearchContext(LIB_DESCRIPTORS["cudart"], platform=WindowsSearchPlatform(target_arch="arm64")) + result = find_via_ctk_root(ctx, str(ctk_root)) + assert result is not None + assert result.abs_path == str(arm64_lib) + assert result.found_via == "system-ctk-root" + + # --------------------------------------------------------------------------- # _resolve_system_loaded_abs_path_in_subprocess # --------------------------------------------------------------------------- diff --git a/cuda_pathfinder/tests/test_descriptor_catalog.py b/cuda_pathfinder/tests/test_descriptor_catalog.py index b2c8eece4bb..3b643aa2e77 100644 --- a/cuda_pathfinder/tests/test_descriptor_catalog.py +++ b/cuda_pathfinder/tests/test_descriptor_catalog.py @@ -13,10 +13,11 @@ import pytest -from cuda.pathfinder._dynamic_libs.descriptor_catalog import DESCRIPTOR_CATALOG, DescriptorSpec +from cuda.pathfinder._dynamic_libs.descriptor_catalog import DESCRIPTOR_CATALOG, DescriptorSpec, WindowsSearchDirs _VALID_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$") _VALID_PACKAGED_WITH_VALUES = {"ctk", "other", "driver"} +_VALID_WINDOWS_ARCHES = ("x64", "arm64") _CATALOG_BY_NAME = {spec.name: spec for spec in DESCRIPTOR_CATALOG} @@ -59,7 +60,7 @@ def test_no_self_dependency(spec: DescriptorSpec): def test_driver_libs_have_no_site_packages(spec: DescriptorSpec): """Driver libs are system-search-only; site-packages paths would be unused.""" assert not spec.site_packages_linux, f"driver lib {spec.name} has site_packages_linux" - assert not spec.site_packages_windows, f"driver lib {spec.name} has site_packages_windows" + assert spec.site_packages_windows == WindowsSearchDirs(), f"driver lib {spec.name} has site_packages_windows" @pytest.mark.parametrize( @@ -85,6 +86,35 @@ def test_windows_dlls_look_like_dlls(spec: DescriptorSpec): assert dll.endswith(".dll"), f"Unexpected Windows DLL format: {dll}" +@pytest.mark.parametrize("spec", DESCRIPTOR_CATALOG, ids=lambda s: s.name) +@pytest.mark.agent_authored(model="gpt-5") +def test_supported_windows_arch_is_explicit_and_canonical(spec: DescriptorSpec): + expected = tuple(arch for arch in _VALID_WINDOWS_ARCHES if arch in spec.supported_windows_arch) + assert spec.supported_windows_arch == expected + assert bool(spec.supported_windows_arch) == bool(spec.windows_dlls) + + +@pytest.mark.parametrize("spec", DESCRIPTOR_CATALOG, ids=lambda s: s.name) +@pytest.mark.agent_authored(model="gpt-5") +def test_windows_search_dirs_do_not_include_unsupported_arches(spec: DescriptorSpec): + if not spec.windows_dlls: + return + for arch in _VALID_WINDOWS_ARCHES: + if arch not in spec.supported_windows_arch: + assert not spec.site_packages_windows.for_arch(arch) + assert not spec.anchor_rel_dirs_windows.for_arch(arch) + + +@pytest.mark.agent_authored(model="gpt-5") +def test_cusparselt_windows_metadata_matches_wheel_layouts(): + spec = _CATALOG_BY_NAME["cusparseLt"] + assert spec.supported_windows_arch == ("x64", "arm64") + assert spec.site_packages_windows == WindowsSearchDirs( + x64=("nvidia/cu13/bin/x64", "nvidia/cusparselt/bin"), + arm64=("nvidia/cu13/bin/arm64",), + ) + + @pytest.mark.parametrize("spec", DESCRIPTOR_CATALOG, ids=lambda s: s.name) def test_ctk_root_canary_anchors_reference_known_ctk_libs(spec: DescriptorSpec): for anchor in spec.ctk_root_canary_anchor_libnames: @@ -96,3 +126,10 @@ def test_ctk_root_canary_anchors_reference_known_ctk_libs(spec: DescriptorSpec): def test_only_ctk_libs_define_ctk_root_canary_anchors(spec: DescriptorSpec): if spec.ctk_root_canary_anchor_libnames: assert spec.packaged_with == "ctk", f"{spec.name} defines canary anchors but is not a CTK lib" + + +@pytest.mark.agent_authored(model="gpt-5") +def test_only_nvvm_requires_windows_binary_arch_check(): + checked_libs = {spec.name for spec in DESCRIPTOR_CATALOG if spec.requires_windows_binary_arch_check} + + assert checked_libs == {"nvvm"} diff --git a/cuda_pathfinder/tests/test_lib_descriptor.py b/cuda_pathfinder/tests/test_lib_descriptor.py index cda96131e13..8715f9181cc 100644 --- a/cuda_pathfinder/tests/test_lib_descriptor.py +++ b/cuda_pathfinder/tests/test_lib_descriptor.py @@ -13,10 +13,21 @@ LIBNAMES_REQUIRING_RTLD_DEEPBIND, SITE_PACKAGES_LIBDIRS_LINUX, SITE_PACKAGES_LIBDIRS_WINDOWS, + SITE_PACKAGES_LIBDIRS_WINDOWS_ARM64, + SITE_PACKAGES_LIBDIRS_WINDOWS_CTK, + SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_X64, + SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER, + SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER_X64, + SITE_PACKAGES_LIBDIRS_WINDOWS_X64, SUPPORTED_LIBNAMES, + SUPPORTED_LIBNAMES_LINUX, + SUPPORTED_LIBNAMES_WINDOWS, + SUPPORTED_LIBNAMES_WINDOWS_ARM64, + SUPPORTED_LIBNAMES_WINDOWS_X64, SUPPORTED_LINUX_SONAMES, SUPPORTED_WINDOWS_DLLS, ) +from cuda.pathfinder._utils.platform_aware import IS_WINDOWS, IS_WINDOWS_ARM64, IS_WINDOWS_X64 # --------------------------------------------------------------------------- # Registry completeness @@ -56,9 +67,49 @@ def test_site_packages_linux_match(name): assert LIB_DESCRIPTORS[name].site_packages_linux == SITE_PACKAGES_LIBDIRS_LINUX.get(name, ()) +@pytest.mark.parametrize( + ("target_arch", "site_packages_libdirs"), + [ + ("x64", SITE_PACKAGES_LIBDIRS_WINDOWS_X64), + ("arm64", SITE_PACKAGES_LIBDIRS_WINDOWS_ARM64), + ], +) @pytest.mark.parametrize("name", sorted(LIB_DESCRIPTORS)) -def test_site_packages_windows_match(name): - assert LIB_DESCRIPTORS[name].site_packages_windows == SITE_PACKAGES_LIBDIRS_WINDOWS.get(name, ()) +@pytest.mark.agent_authored(model="gpt-5") +def test_site_packages_windows_match(name, target_arch, site_packages_libdirs): + assert LIB_DESCRIPTORS[name].site_packages_windows.for_arch(target_arch) == site_packages_libdirs.get(name, ()) + + +@pytest.mark.agent_authored(model="gpt-5") +def test_legacy_site_packages_windows_tables_are_x64_aliases(): + assert SITE_PACKAGES_LIBDIRS_WINDOWS_CTK is SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_X64 + assert SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER is SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER_X64 + assert SITE_PACKAGES_LIBDIRS_WINDOWS is SITE_PACKAGES_LIBDIRS_WINDOWS_X64 + + +@pytest.mark.agent_authored(model="gpt-5") +def test_legacy_supported_libnames_windows_is_x64_alias(): + assert SUPPORTED_LIBNAMES_WINDOWS is SUPPORTED_LIBNAMES_WINDOWS_X64 + + +@pytest.mark.agent_authored(model="gpt-5") +def test_supported_libnames_selects_current_platform_and_arch(): + if not IS_WINDOWS: + expected = SUPPORTED_LIBNAMES_LINUX + elif IS_WINDOWS_X64: + expected = SUPPORTED_LIBNAMES_WINDOWS_X64 + else: + assert IS_WINDOWS_ARM64 + expected = SUPPORTED_LIBNAMES_WINDOWS_ARM64 + assert SUPPORTED_LIBNAMES is expected + + +@pytest.mark.agent_authored(model="gpt-5") +def test_arch_specific_ctk_libname_projections(): + assert "cudla" not in SUPPORTED_LIBNAMES_WINDOWS_X64 + assert "cudla" in SUPPORTED_LIBNAMES_WINDOWS_ARM64 + assert "nvjpeg" in SUPPORTED_LIBNAMES_WINDOWS_X64 + assert "nvjpeg" in SUPPORTED_LIBNAMES_WINDOWS_ARM64 @pytest.mark.parametrize("name", sorted(LIB_DESCRIPTORS)) diff --git a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py index 3e240dcf468..ad42e24e63e 100644 --- a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py +++ b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py @@ -25,32 +25,49 @@ assert STRICTNESS in ("see_what_works", "all_must_work") +@pytest.mark.agent_authored(model="gpt-5") +def test_loader_uses_all_available_libnames(): + assert supported_nvidia_libs.ALL_AVAILABLE_LIBNAMES == load_nvidia_dynamic_lib_module.ALL_AVAILABLE_LIBNAMES + + def test_supported_libnames_linux_sonames_consistency(): assert tuple(sorted(supported_nvidia_libs.SUPPORTED_LIBNAMES_LINUX)) == tuple( sorted(supported_nvidia_libs.SUPPORTED_LINUX_SONAMES_CTK.keys()) ) -def test_supported_libnames_windows_dlls_consistency(): - assert tuple(sorted(supported_nvidia_libs.SUPPORTED_LIBNAMES_WINDOWS)) == tuple( - sorted(supported_nvidia_libs.SUPPORTED_WINDOWS_DLLS_CTK.keys()) - ) - - def test_supported_libnames_linux_site_packages_libdirs_ctk_consistency(): assert tuple(sorted(supported_nvidia_libs.SUPPORTED_LIBNAMES_LINUX)) == tuple( sorted(supported_nvidia_libs.SITE_PACKAGES_LIBDIRS_LINUX_CTK.keys()) ) -def test_supported_libnames_windows_site_packages_libdirs_ctk_consistency(): +@pytest.mark.parametrize( + ("site_packages_libdirs", "supported_libnames"), + [ + pytest.param( + supported_nvidia_libs.SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_X64, + supported_nvidia_libs.SUPPORTED_LIBNAMES_WINDOWS_X64, + id="x64", + ), + pytest.param( + supported_nvidia_libs.SITE_PACKAGES_LIBDIRS_WINDOWS_CTK_ARM64, + supported_nvidia_libs.SUPPORTED_LIBNAMES_WINDOWS_ARM64, + id="arm64", + ), + ], +) +@pytest.mark.human_reviewed +def test_supported_libnames_windows_site_packages_libdirs_ctk_consistency( + site_packages_libdirs, + supported_libnames, +): # Not every Windows CTK library ships in a pip wheel (e.g. cudla is loaded # from the local CUDA Toolkit only), so a library may legitimately omit # site_packages_windows. Only assert that every site-packages entry maps to # a supported Windows libname, not the other way around. - site_packages_libnames = set(supported_nvidia_libs.SITE_PACKAGES_LIBDIRS_WINDOWS_CTK.keys()) - supported_libnames = set(supported_nvidia_libs.SUPPORTED_LIBNAMES_WINDOWS) - assert site_packages_libnames <= supported_libnames + site_packages_libnames = set(site_packages_libdirs) + assert site_packages_libnames <= set(supported_libnames) @pytest.mark.parametrize("dict_name", ["SUPPORTED_LINUX_SONAMES", "SUPPORTED_WINDOWS_DLLS"]) @@ -88,7 +105,7 @@ def test_unknown_libname_raises_dynamic_lib_unknown_error(): def test_known_but_platform_unavailable_libname_raises_dynamic_lib_not_available_error(monkeypatch): load_nvidia_dynamic_lib.cache_clear() monkeypatch.setattr(load_nvidia_dynamic_lib_module, "_ALL_KNOWN_LIBNAMES", frozenset(("known_but_unavailable",))) - monkeypatch.setattr(load_nvidia_dynamic_lib_module, "_ALL_SUPPORTED_LIBNAMES", frozenset()) + monkeypatch.setattr(load_nvidia_dynamic_lib_module, "ALL_AVAILABLE_LIBNAMES", frozenset()) monkeypatch.setattr(load_nvidia_dynamic_lib_module, "_PLATFORM_NAME", "TestOS") with pytest.raises( DynamicLibNotAvailableError, diff --git a/cuda_pathfinder/tests/test_search_steps.py b/cuda_pathfinder/tests/test_search_steps.py index 1b881707dfb..54136dc34e1 100644 --- a/cuda_pathfinder/tests/test_search_steps.py +++ b/cuda_pathfinder/tests/test_search_steps.py @@ -9,6 +9,9 @@ import pytest +from cuda.pathfinder import UnsupportedArchError +from cuda.pathfinder._dynamic_libs import search_platform as search_platform_mod +from cuda.pathfinder._dynamic_libs.descriptor_catalog import WindowsSearchDirs from cuda.pathfinder._dynamic_libs.lib_descriptor import LIB_DESCRIPTORS, LibDescriptor from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError from cuda.pathfinder._dynamic_libs.search_platform import LinuxSearchPlatform, WindowsSearchPlatform @@ -23,6 +26,7 @@ find_in_site_packages, run_find_steps, ) +from cuda.pathfinder._utils import windows_arch as windows_arch_mod _STEPS_MOD = "cuda.pathfinder._dynamic_libs.search_steps" _PLAT_MOD = "cuda.pathfinder._dynamic_libs.search_platform" @@ -40,7 +44,10 @@ def _make_desc(name: str = "cudart", **overrides) -> LibDescriptor: "linux_sonames": ("libcudart.so",), "windows_dlls": ("cudart64_12.dll",), "site_packages_linux": (os.path.join("nvidia", "cuda_runtime", "lib"),), - "site_packages_windows": (os.path.join("nvidia", "cuda_runtime", "bin"),), + "site_packages_windows": WindowsSearchDirs( + x64=(os.path.join("nvidia", "cuda_runtime", "bin"),), + arm64=(os.path.join("nvidia", "cuda_runtime", "bin"),), + ), } defaults.update(overrides) return LibDescriptor(**defaults) @@ -52,6 +59,23 @@ def _ctx(desc: LibDescriptor | None = None, *, platform=None) -> SearchContext: return SearchContext(desc or _make_desc(), platform=platform) +def _patch_site_packages_search(mocker, root): + def _find_sub_dirs(sub_dirs): + path = root.joinpath(*sub_dirs) + return [str(path)] if path.is_dir() else [] + + return mocker.patch(f"{_PLAT_MOD}.find_sub_dirs_all_sitepackages", side_effect=_find_sub_dirs) + + +def _write_pe(path, machine): + image = bytearray(0x86) + image[:2] = b"MZ" + image[0x3C:0x40] = (0x80).to_bytes(4, "little") + image[0x80:0x84] = b"PE\0\0" + image[0x84:0x86] = machine.to_bytes(2, "little") + path.write_bytes(image) + + # --------------------------------------------------------------------------- # SearchContext # --------------------------------------------------------------------------- @@ -67,7 +91,7 @@ def test_lib_searched_for_linux(self): assert ctx.lib_searched_for == "libcublas.so" def test_lib_searched_for_windows(self): - ctx = SearchContext(_make_desc(name="cublas"), platform=WindowsSearchPlatform()) + ctx = SearchContext(_make_desc(name="cublas"), platform=WindowsSearchPlatform(target_arch="x64")) assert ctx.lib_searched_for == "cublas*.dll" def test_raise_not_found_includes_messages(self): @@ -83,6 +107,71 @@ def test_raise_not_found_empty_messages(self): ctx.raise_not_found() +# --------------------------------------------------------------------------- +# Windows Python architecture detection +# --------------------------------------------------------------------------- + + +class TestWindowsPythonArch: + @pytest.mark.agent_authored(model="gpt-5") + def test_linux_platform_does_not_detect_windows_arch(self, mocker): + mocker.patch.object(search_platform_mod, "IS_WINDOWS", False) + get_windows_arch = mocker.patch.object(search_platform_mod, "windows_python_arch") + + platform = search_platform_mod._platform_for_current_system() + + assert isinstance(platform, LinuxSearchPlatform) + get_windows_arch.assert_not_called() + + @pytest.mark.agent_authored(model="gpt-5") + def test_detects_sysconfig_x64(self, mocker): + mocker.patch.object(windows_arch_mod.sysconfig, "get_platform", return_value="win-amd64") + + assert windows_arch_mod.windows_python_arch() == "x64" + + @pytest.mark.agent_authored(model="gpt-5") + def test_detects_sysconfig_arm64(self, mocker): + mocker.patch.object(windows_arch_mod.sysconfig, "get_platform", return_value="win-arm64") + + assert windows_arch_mod.windows_python_arch() == "arm64" + + @pytest.mark.agent_authored(model="gpt-5") + def test_rejects_unknown_sysconfig_tag(self, mocker): + mocker.patch.object(windows_arch_mod.sysconfig, "get_platform", return_value="custom-win") + + with pytest.raises( + UnsupportedArchError, + match=r"Unsupported Windows Python platform tag: 'custom-win'.*win-amd64.*win-arm64", + ) as exc_info: + windows_arch_mod.windows_python_arch() + assert exc_info.value.platform_tag == "custom-win" + + +@pytest.mark.parametrize( + ("machine", "target_arch", "expected"), + ( + (0x8664, "x64", True), + (0x8664, "arm64", False), + (0xAA64, "x64", False), + (0xAA64, "arm64", True), + ), +) +@pytest.mark.agent_authored(model="gpt-5") +def test_windows_pe_matches_arch(tmp_path, machine, target_arch, expected): + dll = tmp_path / "test.dll" + _write_pe(dll, machine) + + assert windows_arch_mod.windows_pe_matches_arch(str(dll), target_arch) is expected + + +@pytest.mark.agent_authored(model="gpt-5") +def test_windows_pe_matches_arch_rejects_malformed_file(tmp_path): + dll = tmp_path / "test.dll" + dll.write_bytes(b"not a PE file") + + assert windows_arch_mod.windows_pe_matches_arch(str(dll), "x64") is False + + # --------------------------------------------------------------------------- # find_in_site_packages # --------------------------------------------------------------------------- @@ -90,7 +179,7 @@ def test_raise_not_found_empty_messages(self): class TestFindInSitePackages: def test_returns_none_when_no_rel_dirs(self): - desc = _make_desc(site_packages_linux=(), site_packages_windows=()) + desc = _make_desc(site_packages_linux=(), site_packages_windows=WindowsSearchDirs()) result = find_in_site_packages(_ctx(desc)) assert result is None @@ -127,13 +216,93 @@ def test_found_windows(self, mocker, tmp_path): desc = _make_desc( name="cudart", - site_packages_windows=(os.path.join("nvidia", "cuda_runtime", "bin"),), + site_packages_windows=WindowsSearchDirs( + x64=(os.path.join("nvidia", "cuda_runtime", "bin"),), + arm64=(os.path.join("nvidia", "cuda_runtime", "bin"),), + ), ) - result = find_in_site_packages(_ctx(desc, platform=WindowsSearchPlatform())) + result = find_in_site_packages(_ctx(desc, platform=WindowsSearchPlatform(target_arch="x64"))) assert result is not None assert result.abs_path == str(dll) assert result.found_via == "site-packages" + @pytest.mark.agent_authored(model="gpt-5") + def test_found_windows_arm64_prefers_cuda13_arch_dir_to_cuda12(self, mocker, tmp_path): + x86_64_dir = tmp_path / "nvidia" / "cu13" / "bin" / "x86_64" + arm64_dir = tmp_path / "nvidia" / "cu13" / "bin" / "arm64" + cuda12_dir = tmp_path / "nvidia" / "cuda_runtime" / "bin" + x86_64_dir.mkdir(parents=True) + arm64_dir.mkdir(parents=True) + cuda12_dir.mkdir(parents=True) + (x86_64_dir / "cudart64_12.dll").touch() + (cuda12_dir / "cudart64_12.dll").touch() + arm64_dll = arm64_dir / "cudart64_12.dll" + arm64_dll.touch() + + _patch_site_packages_search(mocker, tmp_path) + mocker.patch(f"{_PLAT_MOD}.is_suppressed_dll_file", return_value=False) + + desc = LIB_DESCRIPTORS["cudart"] + result = find_in_site_packages(_ctx(desc, platform=WindowsSearchPlatform(target_arch="arm64"))) + assert result is not None + assert result.abs_path == str(arm64_dll) + assert result.found_via == "site-packages" + + @pytest.mark.agent_authored(model="gpt-5") + def test_found_windows_x64_prefers_cuda13_arch_dir_to_cuda12(self, mocker, tmp_path): + x86_64_dir = tmp_path / "nvidia" / "cu13" / "bin" / "x86_64" + arm64_dir = tmp_path / "nvidia" / "cu13" / "bin" / "arm64" + cuda12_dir = tmp_path / "nvidia" / "cuda_runtime" / "bin" + x86_64_dir.mkdir(parents=True) + arm64_dir.mkdir(parents=True) + cuda12_dir.mkdir(parents=True) + x86_64_dll = x86_64_dir / "cudart64_12.dll" + x86_64_dll.touch() + (arm64_dir / "cudart64_12.dll").touch() + (cuda12_dir / "cudart64_12.dll").touch() + + _patch_site_packages_search(mocker, tmp_path) + mocker.patch(f"{_PLAT_MOD}.is_suppressed_dll_file", return_value=False) + + desc = LIB_DESCRIPTORS["cudart"] + result = find_in_site_packages(_ctx(desc, platform=WindowsSearchPlatform(target_arch="x64"))) + assert result is not None + assert result.abs_path == str(x86_64_dll) + assert result.found_via == "site-packages" + + @pytest.mark.agent_authored(model="gpt-5") + def test_found_windows_x64_uses_cuda12_when_cuda13_is_absent(self, mocker, tmp_path): + cuda12_dir = tmp_path / "nvidia" / "cuda_runtime" / "bin" + cuda12_dir.mkdir(parents=True) + cuda12_dll = cuda12_dir / "cudart64_12.dll" + cuda12_dll.touch() + + _patch_site_packages_search(mocker, tmp_path) + mocker.patch(f"{_PLAT_MOD}.is_suppressed_dll_file", return_value=False) + + desc = LIB_DESCRIPTORS["cudart"] + result = find_in_site_packages(_ctx(desc, platform=WindowsSearchPlatform(target_arch="x64"))) + assert result is not None + assert result.abs_path == str(cuda12_dll) + assert result.found_via == "site-packages" + + @pytest.mark.agent_authored(model="gpt-5") + def test_found_windows_arm64_skips_cuda12_when_cuda13_is_absent(self, mocker, tmp_path): + cuda12_dir = tmp_path / "nvidia" / "cuda_runtime" / "bin" + cuda12_dir.mkdir(parents=True) + (cuda12_dir / "cudart64_12.dll").touch() + + _patch_site_packages_search(mocker, tmp_path) + mocker.patch(f"{_PLAT_MOD}.is_suppressed_dll_file", return_value=False) + + desc = LIB_DESCRIPTORS["cudart"] + platform = WindowsSearchPlatform(target_arch="arm64") + assert platform.site_packages_rel_dirs(desc) == ("nvidia/cu13/bin/arm64",) + + result = find_in_site_packages(_ctx(desc, platform=platform)) + + assert result is None + def test_not_found_appends_error(self, mocker, tmp_path): empty_dir = tmp_path / "nvidia" / "cuda_runtime" / "lib" empty_dir.mkdir(parents=True) @@ -241,11 +410,28 @@ def test_found_windows(self, mocker, tmp_path): mocker.patch.dict(os.environ, {"CONDA_PREFIX": str(tmp_path)}) - result = find_in_conda(_ctx(platform=WindowsSearchPlatform())) + result = find_in_conda(_ctx(platform=WindowsSearchPlatform(target_arch="x64"))) assert result is not None assert result.abs_path == str(dll) assert result.found_via == "conda" + @pytest.mark.agent_authored(model="gpt-5") + def test_found_windows_arm64_prefers_arch_dir(self, mocker, tmp_path): + x64_dir = tmp_path / "Library" / "bin" / "x64" + arm64_dir = tmp_path / "Library" / "bin" / "arm64" + x64_dir.mkdir(parents=True) + arm64_dir.mkdir(parents=True) + (x64_dir / "cudart64_12.dll").touch() + arm64_dll = arm64_dir / "cudart64_12.dll" + arm64_dll.touch() + + mocker.patch.dict(os.environ, {"CONDA_PREFIX": str(tmp_path)}) + + result = find_in_conda(_ctx(platform=WindowsSearchPlatform(target_arch="arm64"))) + assert result is not None + assert result.abs_path == str(arm64_dll) + assert result.found_via == "conda" + # The next three tests cover the Linux glob fallback in # cuda.pathfinder._dynamic_libs.search_platform.LinuxSearchPlatform.find_in_lib_dir, # which is exercised by find_in_conda (and find_in_cuda_path) when the @@ -326,11 +512,57 @@ def test_found_windows(self, mocker, tmp_path): mocker.patch(f"{_STEPS_MOD}.get_cuda_path_or_home", return_value=str(tmp_path)) - result = find_in_cuda_path(_ctx(platform=WindowsSearchPlatform())) + result = find_in_cuda_path(_ctx(platform=WindowsSearchPlatform(target_arch="x64"))) assert result is not None assert result.abs_path == str(dll) assert result.found_via == "CUDA_PATH" + @pytest.mark.agent_authored(model="gpt-5") + def test_found_windows_arm64_prefers_arch_dir(self, mocker, tmp_path): + x64_dir = tmp_path / "bin" / "x64" + arm64_dir = tmp_path / "bin" / "arm64" + x64_dir.mkdir(parents=True) + arm64_dir.mkdir(parents=True) + (x64_dir / "cudart64_12.dll").touch() + arm64_dll = arm64_dir / "cudart64_12.dll" + arm64_dll.touch() + + mocker.patch(f"{_STEPS_MOD}.get_cuda_path_or_home", return_value=str(tmp_path)) + + result = find_in_cuda_path(_ctx(platform=WindowsSearchPlatform(target_arch="arm64"))) + assert result is not None + assert result.abs_path == str(arm64_dll) + assert result.found_via == "CUDA_PATH" + + @pytest.mark.parametrize( + ("target_arch", "machine", "expected_found"), + ( + ("x64", 0x8664, True), + ("x64", 0xAA64, False), + ("arm64", 0x8664, False), + ("arm64", 0xAA64, True), + ), + ) + @pytest.mark.agent_authored(model="gpt-5") + def test_nvvm_windows_checks_binary_arch(self, mocker, tmp_path, target_arch, machine, expected_found): + nvvm_dir = tmp_path / "nvvm" / "bin" + nvvm_dir.mkdir(parents=True) + dll = nvvm_dir / "nvvm64_40_0.dll" + _write_pe(dll, machine) + + mocker.patch(f"{_STEPS_MOD}.get_cuda_path_or_home", return_value=str(tmp_path)) + + ctx = _ctx(LIB_DESCRIPTORS["nvvm"], platform=WindowsSearchPlatform(target_arch=target_arch)) + result = find_in_cuda_path(ctx) + + assert (result is not None) is expected_found + if expected_found: + assert result is not None + assert result.abs_path == str(dll) + assert result.found_via == "CUDA_PATH" + else: + assert any(f"No {target_arch}-compatible PE file" in message for message in ctx.error_messages) + # --------------------------------------------------------------------------- # run_find_steps @@ -388,19 +620,63 @@ def test_early_and_late_are_disjoint(self): class TestAnchorRelDirs: """Verify that descriptor anchor paths drive directory resolution.""" + @pytest.mark.agent_authored(model="gpt-5") + def test_windows_search_dirs_arch_only_constructors(self): + assert WindowsSearchDirs.x64_only("first", "second") == WindowsSearchDirs(x64=("first", "second")) + assert WindowsSearchDirs.arm64_only("first", "second") == WindowsSearchDirs(arm64=("first", "second")) + def test_nvvm_has_custom_linux_paths(self): desc = LIB_DESCRIPTORS["nvvm"] assert desc.anchor_rel_dirs_linux == ("nvvm/lib64",) def test_nvvm_has_custom_windows_paths(self): desc = LIB_DESCRIPTORS["nvvm"] - assert desc.anchor_rel_dirs_windows == ("nvvm/bin/*", "nvvm/bin") + assert desc.anchor_rel_dirs_windows.for_arch("x64") == ("nvvm/bin/x64", "nvvm/bin") + assert desc.anchor_rel_dirs_windows.for_arch("arm64") == ("nvvm/bin",) + + @pytest.mark.agent_authored(model="gpt-5") + def test_cupti_has_custom_windows_paths(self): + desc = LIB_DESCRIPTORS["cupti"] + assert desc.anchor_rel_dirs_windows.for_arch("x64") == ( + "extras/CUPTI/lib/x64", + "extras/CUPTI/lib64", + "bin", + ) + assert desc.anchor_rel_dirs_windows.for_arch("arm64") == ("extras/CUPTI/lib/arm64",) @pytest.mark.parametrize("libname", ["cudart", "cublas", "nvrtc"]) def test_regular_ctk_libs_use_defaults(self, libname): desc = LIB_DESCRIPTORS[libname] assert desc.anchor_rel_dirs_linux == ("lib64", "lib") - assert desc.anchor_rel_dirs_windows == ("bin/x64", "bin") + assert desc.anchor_rel_dirs_windows.for_arch("x64") == ("bin/x64", "bin") + assert desc.anchor_rel_dirs_windows.for_arch("arm64") == ("bin/arm64",) + + @pytest.mark.agent_authored(model="gpt-5") + def test_cudla_uses_arm64_only_windows_anchor(self): + desc = LIB_DESCRIPTORS["cudla"] + + assert desc.anchor_rel_dirs_windows.for_arch("x64") == () + assert desc.anchor_rel_dirs_windows.for_arch("arm64") == ("bin/arm64",) + + @pytest.mark.agent_authored(model="gpt-5") + def test_windows_anchor_dirs_select_arm64(self): + desc = _make_desc( + anchor_rel_dirs_windows=WindowsSearchDirs( + x64=("bin/x64", "bin"), + arm64=("bin/arm64", "bin"), + ) + ) + assert WindowsSearchPlatform(target_arch="arm64").anchor_rel_dirs(desc) == ("bin/arm64", "bin") + + @pytest.mark.agent_authored(model="gpt-5") + def test_windows_anchor_dirs_select_x64(self): + desc = _make_desc( + anchor_rel_dirs_windows=WindowsSearchDirs( + x64=("bin/x64", "bin"), + arm64=("bin/arm64", "bin"), + ) + ) + assert WindowsSearchPlatform(target_arch="x64").anchor_rel_dirs(desc) == ("bin/x64", "bin") def test_find_lib_dir_uses_descriptor_linux(self, tmp_path): (tmp_path / "nvvm" / "lib64").mkdir(parents=True) @@ -413,11 +689,33 @@ def test_find_lib_dir_uses_descriptor_linux(self, tmp_path): def test_find_lib_dir_uses_descriptor_windows(self, tmp_path): (tmp_path / "nvvm" / "bin").mkdir(parents=True) - desc = _make_desc(name="nvvm", anchor_rel_dirs_windows=("nvvm/bin/*", "nvvm/bin")) - result = _find_lib_dir_using_anchor(desc, WindowsSearchPlatform(), str(tmp_path)) + desc = _make_desc( + name="nvvm", + anchor_rel_dirs_windows=WindowsSearchDirs( + x64=("nvvm/bin/x64", "nvvm/bin"), + arm64=("nvvm/bin/arm64", "nvvm/bin"), + ), + ) + result = _find_lib_dir_using_anchor(desc, WindowsSearchPlatform(target_arch="x64"), str(tmp_path)) assert result is not None assert result.endswith(os.path.join("nvvm", "bin")) + @pytest.mark.agent_authored(model="gpt-5") + def test_find_lib_dir_windows_arm64_uses_arm64_anchor(self, tmp_path): + (tmp_path / "bin" / "x64").mkdir(parents=True) + (tmp_path / "bin" / "arm64").mkdir(parents=True) + + desc = _make_desc( + name="cudart", + anchor_rel_dirs_windows=WindowsSearchDirs( + x64=("bin/x64", "bin"), + arm64=("bin/arm64",), + ), + ) + result = _find_lib_dir_using_anchor(desc, WindowsSearchPlatform(target_arch="arm64"), str(tmp_path)) + assert result is not None + assert result.endswith(os.path.join("bin", "arm64")) + def test_find_lib_dir_returns_none_when_no_match(self, tmp_path): desc = _make_desc(anchor_rel_dirs_linux=("nonexistent",)) assert _find_lib_dir_using_anchor(desc, LinuxSearchPlatform(), str(tmp_path)) is None diff --git a/toolshed/_catalog_writer.py b/toolshed/_catalog_writer.py deleted file mode 100644 index b41fb5838dd..00000000000 --- a/toolshed/_catalog_writer.py +++ /dev/null @@ -1,182 +0,0 @@ -#!/usr/bin/env python3 - -# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -"""Shared helper for reading, updating, and rewriting descriptor_catalog.py. - -Each toolshed script that extracts data from CTK distributions or wheel -layouts uses this module to merge its findings into the authored catalog -without touching fields it doesn't own. -""" - -from __future__ import annotations - -import dataclasses -import json -import sys -from pathlib import Path - -# Ensure the cuda_pathfinder package is importable. -_REPO_ROOT = Path(__file__).resolve().parents[1] -_PATHFINDER_ROOT = _REPO_ROOT / "cuda_pathfinder" -if str(_PATHFINDER_ROOT) not in sys.path: - sys.path.insert(0, str(_PATHFINDER_ROOT)) - -from cuda.pathfinder._dynamic_libs.descriptor_catalog import ( # noqa: E402 - DESCRIPTOR_CATALOG, - DescriptorSpec, -) - -CATALOG_PATH = _PATHFINDER_ROOT / "cuda" / "pathfinder" / "_dynamic_libs" / "descriptor_catalog.py" - -_DEFAULTS = DescriptorSpec(name="", packaged_with="ctk") - -_SECTION_COMMENTS = { - "ctk": ( - " # -----------------------------------------------------------------------\n" - " # CTK (CUDA Toolkit) libraries\n" - " # -----------------------------------------------------------------------" - ), - "other": ( - " # -----------------------------------------------------------------------\n" - " # Third-party / separately packaged libraries\n" - " # -----------------------------------------------------------------------" - ), - "driver": ( - " # -----------------------------------------------------------------------\n" - " # Driver libraries (system-search only, no CTK cascade)\n" - " # -----------------------------------------------------------------------" - ), -} - - -def _quote(s: str) -> str: - return json.dumps(s) - - -def _render_tuple(values: tuple[str, ...]) -> str: - if not values: - return "()" - if len(values) == 1: - return f"({_quote(values[0])},)" - return "(" + ", ".join(_quote(v) for v in values) + ")" - - -def _render_spec(spec: DescriptorSpec) -> str: - """Render a single DescriptorSpec constructor call, omitting default-valued fields.""" - lines = [ - " DescriptorSpec(", - f" name={_quote(spec.name)},", - f' packaged_with="{spec.packaged_with}",', - ] - - tuple_fields = [ - "linux_sonames", - "windows_dlls", - "site_packages_linux", - "site_packages_windows", - "dependencies", - "anchor_rel_dirs_linux", - "anchor_rel_dirs_windows", - "ctk_root_canary_anchor_libnames", - ] - bool_fields = [ - "requires_add_dll_directory", - "requires_rtld_deepbind", - ] - - for field in tuple_fields: - value = getattr(spec, field) - default = getattr(_DEFAULTS, field) - if value != default: - lines.append(f" {field}={_render_tuple(value)},") - - for field in bool_fields: - value = getattr(spec, field) - default = getattr(_DEFAULTS, field) - if value != default: - lines.append(f" {field}={value},") - - lines.append(" ),") - return "\n".join(lines) - - -def render_catalog(specs: tuple[DescriptorSpec, ...]) -> str: - """Render the full descriptor_catalog.py file content.""" - header = '''\ -# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -"""Canonical authored descriptor catalog for dynamic libraries.""" - -from __future__ import annotations - -from dataclasses import dataclass -from typing import Literal - -PackagedWith = Literal["ctk", "other", "driver"] - - -@dataclass(frozen=True, slots=True) -class DescriptorSpec: - name: str - packaged_with: PackagedWith - linux_sonames: tuple[str, ...] = () - windows_dlls: tuple[str, ...] = () - site_packages_linux: tuple[str, ...] = () - site_packages_windows: tuple[str, ...] = () - dependencies: tuple[str, ...] = () - anchor_rel_dirs_linux: tuple[str, ...] = ("lib64", "lib") - anchor_rel_dirs_windows: tuple[str, ...] = ("bin/x64", "bin") - ctk_root_canary_anchor_libnames: tuple[str, ...] = () - requires_add_dll_directory: bool = False - requires_rtld_deepbind: bool = False - - -DESCRIPTOR_CATALOG: tuple[DescriptorSpec, ...] = ( -''' - - body_parts: list[str] = [] - prev_packaged_with = None - for spec in specs: - if spec.packaged_with != prev_packaged_with: - comment = _SECTION_COMMENTS.get(spec.packaged_with) - if comment is not None: - body_parts.append(comment) - prev_packaged_with = spec.packaged_with - body_parts.append(_render_spec(spec)) - - footer = ")\n" - return header + "\n".join(body_parts) + "\n" + footer - - -def load_catalog() -> tuple[DescriptorSpec, ...]: - """Return the current DESCRIPTOR_CATALOG from disk.""" - return DESCRIPTOR_CATALOG - - -def load_catalog_as_dict() -> dict[str, DescriptorSpec]: - """Return the current catalog keyed by name.""" - return {spec.name: spec for spec in DESCRIPTOR_CATALOG} - - -def update_specs( - catalog: tuple[DescriptorSpec, ...], - updates: dict[str, dict[str, object]], -) -> tuple[DescriptorSpec, ...]: - """Apply field updates to matching specs by name, preserving order.""" - result = [] - for spec in catalog: - if spec.name in updates: - result.append(dataclasses.replace(spec, **updates[spec.name])) - else: - result.append(spec) - return tuple(result) - - -def write_catalog(specs: tuple[DescriptorSpec, ...], path: Path | None = None) -> None: - """Render and write the catalog to disk.""" - if path is None: - path = CATALOG_PATH - path.write_text(render_catalog(specs), encoding="utf-8") diff --git a/toolshed/build_pathfinder_dlls.py b/toolshed/build_pathfinder_dlls.py deleted file mode 100755 index 63abba52386..00000000000 --- a/toolshed/build_pathfinder_dlls.py +++ /dev/null @@ -1,118 +0,0 @@ -#!/usr/bin/env python3 - -# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# SPDX-License-Identifier: Apache-2.0 - -"""Scan 7z listing files for .dll names, update descriptor_catalog.py. - -Usage: - # First generate listings from CTK .exe installers: - # for exe in *.exe; do 7z l "$exe" > "${exe%.exe}.txt"; done - python toolshed/build_pathfinder_dlls.py listing1.txt [listing2.txt ...] -""" - -from __future__ import annotations - -import collections -import sys -from pathlib import Path - -sys.path.insert(0, str(Path(__file__).resolve().parent)) -from _catalog_writer import load_catalog, update_specs, write_catalog - - -def _is_suppressed_dll(libname: str, dll: str) -> bool: - if libname == "cudart": - if dll.startswith("cudart32_"): - return True - if dll == "cudart64_65.dll": - # PhysX/files/Common/cudart64_65.dll from CTK 6.5, but shipped with CTK 12.0-12.9 - return True - if dll == "cudart64_101.dll": - # GFExperience.NvStreamSrv/amd64/server/cudart64_101.dll from CTK 10.1, but shipped with CTK 12.0-12.6 - return True - elif libname == "nvrtc": - if dll.endswith(".alt.dll"): - return True - if dll.startswith("nvrtc-builtins"): - return True - elif libname == "nvvm" and dll == "nvvm32.dll": - return True - return False - - -def _parse_listings(paths: list[str]) -> set[str]: - dlls: set[str] = set() - for filename in paths: - lines_iter = iter(Path(filename).read_text().splitlines()) - for line in lines_iter: - if line.startswith("-------------------"): - break - else: - raise RuntimeError(f"------------------- NOT FOUND in {filename}") - for line in lines_iter: - if line.startswith("-------------------"): - break - assert line[52] == " ", line - assert line[53] != " ", line - path = line[53:] - if path.endswith(".dll"): - dll = path.rsplit("/", 1)[1] - dlls.add(dll) - else: - raise RuntimeError(f"------------------- NOT FOUND in {filename}") - return dlls - - -def run(listing_files: list[str]) -> None: - dlls_from_files = _parse_listings(listing_files) - catalog = load_catalog() - - # Longest-prefix-first to avoid ambiguous matches (e.g. "cufftw" before "cufft"). - ctk_names = sorted( - (spec.name for spec in catalog if spec.packaged_with == "ctk"), - key=lambda n: (-len(n), n), - ) - - dlls_in_scope: set[str] = set() - dlls_by_name: dict[str, list[str]] = collections.defaultdict(list) - suppressed: set[str] = set() - - for name in ctk_names: - for dll in sorted(dlls_from_files): - if dll not in dlls_in_scope and dll.startswith(name): - if _is_suppressed_dll(name, dll): - suppressed.add(dll) - else: - dlls_by_name[name].append(dll) - dlls_in_scope.add(dll) - - updates: dict[str, dict[str, object]] = {} - for name, dlls in dlls_by_name.items(): - updates[name] = {"windows_dlls": tuple(dlls)} - - if updates: - write_catalog(update_specs(catalog, updates)) - for name in sorted(updates): - print(f" updated {name}: windows_dlls={updates[name]['windows_dlls']}") - else: - print("No matching DLLs found.") - - if suppressed: - print(f"\nSuppressed DLLs ({len(suppressed)}):") - for dll in sorted(suppressed): - print(f" {dll}") - - out_of_scope = dlls_from_files - dlls_in_scope - if out_of_scope: - print(f"\nDLLs out of scope ({len(out_of_scope)}):") - for dll in sorted(out_of_scope): - print(f" {dll}") - - -if __name__ == "__main__": - if len(sys.argv) < 2: - print("Usage: build_pathfinder_dlls.py <7z-listing.txt> ...", file=sys.stderr) - sys.exit(1) - run(listing_files=sys.argv[1:]) diff --git a/toolshed/build_pathfinder_sonames.py b/toolshed/build_pathfinder_sonames.py deleted file mode 100755 index b3fa6c2efc9..00000000000 --- a/toolshed/build_pathfinder_sonames.py +++ /dev/null @@ -1,93 +0,0 @@ -#!/usr/bin/env python3 - -# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# SPDX-License-Identifier: Apache-2.0 - -"""Scan directories for .so files, extract SONAMEs, update descriptor_catalog.py. - -Usage: - python toolshed/build_pathfinder_sonames.py /path/to/cuda [/more/paths ...] -""" - -from __future__ import annotations - -import os -import subprocess -import sys -from pathlib import Path - -sys.path.insert(0, str(Path(__file__).resolve().parent)) -from _catalog_writer import load_catalog, update_specs, write_catalog - - -def _extract_soname(path: str) -> str | None: - try: - out = subprocess.run( # noqa: S603 - ["readelf", "-d", path], # noqa: S607 - capture_output=True, - text=True, - timeout=10, - ) - except (FileNotFoundError, subprocess.TimeoutExpired): - return None - for line in out.stdout.splitlines(): - if "SONAME" in line: - # Format: 0x000000000000000e (SONAME) Library soname: [libfoo.so.1] - start = line.find("[") - end = line.find("]") - if start != -1 and end != -1: - return line[start + 1 : end] - return None - - -def _find_sonames(roots: list[str]) -> set[str]: - sonames: set[str] = set() - for root in roots: - for dirpath, _dirnames, filenames in os.walk(root): - for fname in filenames: - if ".so" not in fname: - continue - full = os.path.join(dirpath, fname) - if os.path.islink(full): - continue - soname = _extract_soname(full) - if soname is not None: - sonames.add(soname) - return sonames - - -def run(roots: list[str]) -> None: - sonames_found = _find_sonames(roots) - catalog = load_catalog() - - updates: dict[str, dict[str, object]] = {} - matched: set[str] = set() - for spec in catalog: - if spec.packaged_with != "ctk": - continue - prefix = "lib" + spec.name + ".so" - found = tuple(sorted(s for s in sonames_found if s.startswith(prefix))) - if found: - updates[spec.name] = {"linux_sonames": found} - matched.update(found) - - if updates: - write_catalog(update_specs(catalog, updates)) - for name, upd in sorted(updates.items()): - print(f" updated {name}: linux_sonames={upd['linux_sonames']}") - else: - print("No matching sonames found.") - - unmatched = sonames_found - matched - if unmatched: - print(f"\nSONAMEs not matched to any CTK descriptor ({len(unmatched)}):") - for s in sorted(unmatched): - print(f" {s}") - - -if __name__ == "__main__": - if len(sys.argv) < 2: - print("Usage: build_pathfinder_sonames.py [ ...]", file=sys.stderr) - sys.exit(1) - run(roots=sys.argv[1:]) diff --git a/toolshed/collect_site_packages_dll_files.ps1 b/toolshed/collect_site_packages_dll_files.ps1 index f0a6f799242..4efebbf3aab 100644 --- a/toolshed/collect_site_packages_dll_files.ps1 +++ b/toolshed/collect_site_packages_dll_files.ps1 @@ -1,12 +1,11 @@ # collect_site_packages_dll_files.ps1 -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # Usage: # cd cuda-python # powershell -File toolshed\collect_site_packages_dll_files.ps1 -# python .\toolshed\make_site_packages_libdirs.py windows site_packages_dll.txt $ErrorActionPreference = 'Stop' diff --git a/toolshed/collect_site_packages_so_files.sh b/toolshed/collect_site_packages_so_files.sh index 974f6eeae86..a88652bdfe0 100755 --- a/toolshed/collect_site_packages_so_files.sh +++ b/toolshed/collect_site_packages_so_files.sh @@ -1,12 +1,11 @@ #!/bin/bash -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # Usage: # cd cuda-python # ./toolshed/collect_site_packages_so_files.sh -# ./toolshed/make_site_packages_libdirs.py linux site_packages_so.txt set -euo pipefail fresh_venv() { diff --git a/toolshed/make_site_packages_libdirs.py b/toolshed/make_site_packages_libdirs.py deleted file mode 100755 index e1cbcb28825..00000000000 --- a/toolshed/make_site_packages_libdirs.py +++ /dev/null @@ -1,123 +0,0 @@ -#!/usr/bin/env python3 - -# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -"""Parse collected site-packages library paths, update descriptor_catalog.py. - -Usage: - python toolshed/make_site_packages_libdirs.py linux collected_linux.txt - python toolshed/make_site_packages_libdirs.py windows collected_windows.txt -""" - -from __future__ import annotations - -import argparse -import os -import re -import sys -from pathlib import Path -from typing import Dict, Set - -sys.path.insert(0, str(Path(__file__).resolve().parent)) -from _catalog_writer import load_catalog, update_specs, write_catalog - -_SITE_PACKAGES_RE = re.compile(r"(?i)^.*?/site-packages/") - - -def _strip_site_packages_prefix(p: str) -> str: - """Remove any leading '.../site-packages/' (handles '\\' or '/', case-insensitive).""" - p = p.replace("\\", "/") - return _SITE_PACKAGES_RE.sub("", p) - - -def _parse_lines_linux(lines: list[str]) -> Dict[str, Set[str]]: - d: Dict[str, Set[str]] = {} - for raw in lines: - line = raw.strip() - if not line or line.startswith("#"): - continue - line = _strip_site_packages_prefix(line) - dirpath, fname = os.path.split(line) - # Require something like libNAME.so, libNAME.so.12, libNAME.so.12.1, etc. - i = fname.find(".so") - if not fname.startswith("lib") or i == -1: - continue - name = fname[3:i] # e.g. "libnvrtc" -> "nvrtc" - d.setdefault(name, set()).add(dirpath) - return d - - -def _extract_libname_from_dll(fname: str) -> str | None: - """Return base libname per the heuristic, or None if not a .dll.""" - base = os.path.basename(fname) - if not base.lower().endswith(".dll"): - return None - stem = base[:-4] # drop ".dll" - out = [] - for ch in stem: - if ch == "_" or ch.isdigit(): - break - out.append(ch) - name = "".join(out) - return name or None - - -def _parse_lines_windows(lines: list[str]) -> Dict[str, Set[str]]: - """Collect {libname: set(dirnames)} with deduped directories.""" - m: Dict[str, Set[str]] = {} - for raw in lines: - line = raw.strip() - if not line or line.startswith("#"): - continue - line = _strip_site_packages_prefix(line) - dirpath, fname = os.path.split(line) - libname = _extract_libname_from_dll(fname) - if not libname: - continue - m.setdefault(libname, set()).add(dirpath) - return m - - -def main() -> None: - ap = argparse.ArgumentParser( - description="Update site_packages_* in descriptor_catalog.py from collected library paths" - ) - ap.add_argument("platform", choices=["linux", "windows"]) - ap.add_argument("path", help="Text file with one library path per line") - args = ap.parse_args() - - with open(args.path, encoding="utf-8") as f: - lines = f.read().splitlines() - - if args.platform == "linux": - parsed = _parse_lines_linux(lines) - field = "site_packages_linux" - else: - parsed = _parse_lines_windows(lines) - field = "site_packages_windows" - - catalog = load_catalog() - catalog_names = {spec.name for spec in catalog} - - updates: dict[str, dict[str, object]] = {} - for name, dirs in parsed.items(): - if name in catalog_names: - updates[name] = {field: tuple(sorted(dirs))} - - if updates: - write_catalog(update_specs(catalog, updates)) - for name in sorted(updates): - print(f" updated {name}: {field}={updates[name][field]}") - else: - print("No matching libraries found.") - - unmatched = set(parsed.keys()) - catalog_names - if unmatched: - print(f"\nLibraries not in catalog ({len(unmatched)}):") - for name in sorted(unmatched): - print(f" {name}") - - -if __name__ == "__main__": - main() diff --git a/toolshed/update_catalog.py b/toolshed/update_catalog.py deleted file mode 100644 index 800451ca45d..00000000000 --- a/toolshed/update_catalog.py +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/env python3 - -# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# SPDX-License-Identifier: Apache-2.0 - -"""Update descriptor_catalog.py from CTK installations. - -On Linux, scans directories for .so files and extracts SONAMEs via readelf. -On Windows, parses 7z listing files generated from CTK .exe installers. - -Usage: - # Linux — pass one or more CTK lib directories: - python toolshed/update_catalog.py /path/to/ctk12/lib64 /path/to/ctk13/lib64 - - # Windows — pass 7z listing .txt files: - # for exe in *.exe; do 7z l "$exe" > "${exe%.exe}.txt"; done - python toolshed/update_catalog.py listing12.txt listing13.txt -""" - -from __future__ import annotations - -import sys -from pathlib import Path - -sys.path.insert(0, str(Path(__file__).resolve().parent)) - - -def main() -> None: - if len(sys.argv) < 2: - print(__doc__, file=sys.stderr) - sys.exit(1) - - args = sys.argv[1:] - - if sys.platform == "win32": - from build_pathfinder_dlls import run as run_dlls - - run_dlls(listing_files=args) - else: - from build_pathfinder_sonames import run as run_sonames - - run_sonames(roots=args) - - -if __name__ == "__main__": - main() From 915d0da4fe53743dfde34c89d9b6ee8f92b55f39 Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Fri, 31 Jul 2026 16:39:11 -0700 Subject: [PATCH 15/50] fix(cuda.core): surface real CUDA error in Device.set_current() (#2461) --- cuda_core/cuda/core/_device.pyx | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/cuda_core/cuda/core/_device.pyx b/cuda_core/cuda/core/_device.pyx index 9c35fc9355b..29740cb466a 100644 --- a/cuda_core/cuda/core/_device.pyx +++ b/cuda_core/cuda/core/_device.pyx @@ -1289,7 +1289,10 @@ class Device: # use primary ctx h_context = get_primary_context(self._device_id) if h_context.get() == NULL: - raise ValueError("Cannot set NULL context as current") + HANDLE_RETURN(get_last_error()) + raise RuntimeError( + f"Failed to retain the primary context for device {self._device_id}" + ) with nogil: HANDLE_RETURN(cydriver.cuCtxSetCurrent(as_cu(h_context))) self._has_inited = True From d46d82cd6515e969ddea72f95a1e3355687402b6 Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Sat, 1 Aug 2026 10:31:57 -0700 Subject: [PATCH 16/50] cuda.core: fix host memcpy source pointer cast (#2476) --- cuda_core/cuda/core/graph/_graph_node.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cuda_core/cuda/core/graph/_graph_node.pyx b/cuda_core/cuda/core/graph/_graph_node.pyx index 38bc6f955e6..37411c857b5 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyx +++ b/cuda_core/cuda/core/graph/_graph_node.pyx @@ -1003,7 +1003,7 @@ cdef void _init_memcpy_params( params.srcMemoryType = src_type[0] params.dstMemoryType = dst_type[0] if src_type[0] == cydriver.CU_MEMORYTYPE_HOST: - params.srcHost = src + params.srcHost = src else: params.srcDevice = src if dst_type[0] == cydriver.CU_MEMORYTYPE_HOST: From 3887f9135461f3423556b84d94d0f2bde8dc8345 Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Sat, 1 Aug 2026 10:38:15 -0700 Subject: [PATCH 17/50] CI: avoid SIGPIPE when selecting core release tag (#2475) --- .github/workflows/ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 442476ba05e..f36b880beee 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -255,11 +255,11 @@ jobs: GH_TOKEN: ${{ github.token }} run: | # --paginate fetches all pages; jq outputs one name per line per page; - # head -1 takes the first (newest) match since GitHub returns tags - # newest-first. Fails hard if no cuda-core-v* tag is found. + # sed prints the first (newest) match while consuming all pages, so + # gh can complete without SIGPIPE. Fails if no cuda-core-v* tag is found. tag="$(gh api "repos/$GITHUB_REPOSITORY/tags" --paginate \ --jq '.[] | select(.name | startswith("cuda-core-v")) | .name' \ - | head -1)" + | sed -n '1p')" if [[ -z "${tag}" ]]; then echo "::error::No cuda-core-v* tag found in the repository." >&2 exit 1 From 76bceed795d189d57fdd273f3fae87548043a65c Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Sun, 2 Aug 2026 08:52:26 -0400 Subject: [PATCH 18/50] Make pre-commit work on Windows (#2327) * Make pre-commit work on Windows * Update .pre-commit-config.yaml * Address some of the comments in the PR * Simplify type-checking * Address comments in PR * Simplifications * Fix simplifications * Fix type check * Add comment about stubgen-pyx issues * Update CONTRIBUTING.md Co-authored-by: Ralf W. Grosse-Kunstleve * Update cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_windows.py --------- Co-authored-by: Ralf W. Grosse-Kunstleve Co-authored-by: Ralf W. Grosse-Kunstleve --- .github/workflows/ci.yml | 34 +++++++++++ .pre-commit-config.yaml | 4 +- CONTRIBUTING.md | 12 ++++ .../pathfinder/_dynamic_libs/load_dl_linux.py | 58 +++++++++++-------- .../_dynamic_libs/load_dl_windows.py | 22 +++++-- .../_dynamic_libs/platform_loader.py | 6 +- .../cuda/pathfinder/_utils/driver_info.py | 16 ++--- .../tests/test_utils_driver_info.py | 6 +- toolshed/run_stubgen_pyx.py | 54 +++++++++++++++++ 9 files changed, 166 insertions(+), 46 deletions(-) create mode 100644 toolshed/run_stubgen_pyx.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f36b880beee..24b81f406f5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -501,6 +501,38 @@ jobs: with: is-release: ${{ github.ref_type == 'tag' }} + precommit-windows: + name: Pre-commit on Windows + runs-on: windows-latest + if: ${{ github.repository_owner == 'nvidia' && !fromJSON(needs.should-skip.outputs.skip) }} + needs: + - should-skip + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + fetch-depth: 1 + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: '3.13' + + - name: Install pre-commit + shell: bash + run: | + set -euxo pipefail + python -m pip install --upgrade pip pre-commit + + - name: Run pre-commit + shell: bash + run: | + set -euxo pipefail + SKIP=lychee pre-commit run --all-files + checks: name: Check job status if: always() @@ -514,6 +546,7 @@ jobs: - test-linux-aarch64 - test-windows - doc + - precommit-windows steps: - name: Exit run: | @@ -546,6 +579,7 @@ jobs: check_result "should-skip" "success" "${{ needs.should-skip.result }}" check_result "detect-changes" "success" "${{ needs.detect-changes.result }}" check_result "doc" "success" "${{ needs.doc.result }}" + check_result "precommit-windows" "success" "${{ needs.precommit-windows.result }}" # [doc-only] flips these from 'success' to 'skipped' if [[ "$doc_only" == "true" ]]; then expected="skipped"; else expected="success"; fi diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 6e0485eb450..d7453873566 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -69,7 +69,7 @@ repos: - id: stubgen-pyx-cuda-core name: Generate .pyi stubs for cuda_core - entry: stubgen-pyx cuda_core/cuda --continue-on-error --include-private + entry: python ./toolshed/run_stubgen_pyx.py language: python files: ^cuda_core/cuda/.*\.(pyx|pxd)$ pass_filenames: false @@ -103,7 +103,7 @@ repos: - id: check-yaml - id: debug-statements - id: end-of-file-fixer - exclude: &gen_exclude '^(?:cuda_python/README\.md|cuda_bindings/cuda/bindings/.*\.in?|cuda_bindings/docs/source/module/.*\.rst?|.*\.pyi)$' + exclude: &gen_exclude '^(?:cuda_python/README\.md|(?:.*/)?CLAUDE\.md|(?:.*/)?\.git_archival\.txt|cuda_bindings/cuda/bindings/.*\.in?|cuda_bindings/docs/source/module/.*\.rst?|.*\.pyi)$' - id: mixed-line-ending - id: trailing-whitespace exclude: | diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 9f28ec49a38..2a477edddeb 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -25,6 +25,7 @@ Thank you for your interest in contributing to CUDA Python! Based on the type of - [Symptoms of a bad clone](#symptoms-of-a-bad-clone) - [Type stubs for cuda.core](#type-stubs-for-cudacore) - [Pre-commit](#pre-commit) + - [Pre-commit on Windows](#pre-commit-on-windows) - [Signing Your Work](#signing-your-work) - [Code signing](#code-signing) - [Developer Certificate of Origin (DCO)](#developer-certificate-of-origin-dco) @@ -166,6 +167,17 @@ between commits, leaving stale headers or out-of-date stubs in the history. If the hook isn't installed, `pre-commit run` (and CI) will print a visible warning reminding you to run `pre-commit install`. +### Pre-commit on Windows + +For development on Windows (not WSL), the `lychee` pre-commit task will not work +when running `pre-commit run --all-files`. This problem does not occur if you +install the pre-commit hook and run it automatically as part of your `git +commit` workflow. To resolve this, you can either: + +1. Run `pre-commit` in Git Bash, rather than directly in PowerShell or cmd + +2. Skip it by setting the environment variable `SKIP` to `lychee`. This would + be `$env:SKIP = "lychee"` in PowerShell or `set SKIP=lychee` in cmd. ## Signing Your Work diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_linux.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_linux.py index 10a92c20830..24d4d67c9e2 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_linux.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_linux.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 from __future__ import annotations @@ -7,6 +7,7 @@ import ctypes import ctypes.util import os +import sys from typing import TYPE_CHECKING, cast from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL @@ -14,7 +15,10 @@ if TYPE_CHECKING: from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor -CDLL_MODE = os.RTLD_NOW | os.RTLD_GLOBAL +if sys.platform == "linux": + CDLL_MODE = os.RTLD_NOW | os.RTLD_GLOBAL +else: + CDLL_MODE = 0 def _load_libdl() -> ctypes.CDLL: @@ -132,27 +136,35 @@ def _candidate_sonames(desc: LibDescriptor) -> list[str]: return candidates -def check_if_already_loaded_from_elsewhere(desc: LibDescriptor, _have_abs_path: bool) -> LoadedDL | None: - for soname in _candidate_sonames(desc): - try: - handle = ctypes.CDLL(soname, mode=os.RTLD_NOLOAD) - except OSError: - continue - else: - return LoadedDL( - abs_path_for_dynamic_library(desc.name, handle), - True, - handle._handle, - "was-already-loaded-from-elsewhere", - ) - return None - - -def _load_lib(desc: LibDescriptor, filename: str) -> ctypes.CDLL: - cdll_mode = CDLL_MODE - if desc.requires_rtld_deepbind: - cdll_mode |= os.RTLD_DEEPBIND - return ctypes.CDLL(filename, cdll_mode) +if sys.platform == "linux": + + def check_if_already_loaded_from_elsewhere(desc: LibDescriptor, _have_abs_path: bool) -> LoadedDL | None: + for soname in _candidate_sonames(desc): + try: + handle = ctypes.CDLL(soname, mode=os.RTLD_NOLOAD) + except OSError: + continue + else: + return LoadedDL( + abs_path_for_dynamic_library(desc.name, handle), + True, + handle._handle, + "was-already-loaded-from-elsewhere", + ) + return None + + def _load_lib(desc: LibDescriptor, filename: str) -> ctypes.CDLL: + cdll_mode = CDLL_MODE + if desc.requires_rtld_deepbind: + cdll_mode |= os.RTLD_DEEPBIND + return ctypes.CDLL(filename, cdll_mode) +else: + + def check_if_already_loaded_from_elsewhere(_desc: LibDescriptor, _have_abs_path: bool) -> LoadedDL | None: + raise RuntimeError(f"check_if_already_loaded_from_elsewhere() is not supported on platform {sys.platform!r}") + + def _load_lib(_desc: LibDescriptor, _filename: str) -> ctypes.CDLL: + raise RuntimeError(f"_load_lib() is not supported on platform {sys.platform!r}") def load_with_system_search(desc: LibDescriptor) -> LoadedDL | None: diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_windows.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_windows.py index b2f61dfc9af..e9cfbb52366 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_windows.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/load_dl_windows.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 from __future__ import annotations @@ -7,6 +7,7 @@ import ctypes.wintypes import os import struct +import sys import warnings from typing import TYPE_CHECKING @@ -22,7 +23,10 @@ POINTER_ADDRESS_SPACE = 2 ** (struct.calcsize("P") * 8) # Set up kernel32 functions with proper types -kernel32 = ctypes.windll.kernel32 # type: ignore[attr-defined] +windll = getattr(ctypes, "windll", None) +if windll is None: + raise RuntimeError("ctypes.windll is required on Windows") +kernel32 = windll.kernel32 # GetModuleHandleW kernel32.GetModuleHandleW.argtypes = [ctypes.wintypes.LPCWSTR] @@ -45,6 +49,11 @@ kernel32.GetModuleFileNameW.restype = ctypes.wintypes.DWORD +# GetLastError +kernel32.GetLastError.argtypes = [] +kernel32.GetLastError.restype = ctypes.wintypes.DWORD + + def ctypes_handle_to_unsigned_int(handle: ctypes.wintypes.HMODULE) -> int: """Convert ctypes HMODULE to unsigned int.""" handle_uint = int(handle) @@ -73,7 +82,8 @@ def add_dll_directory(dll_abs_path: str) -> None: # the directory must stay on the search path for the process lifetime, and # the handle has no finalizer, so dropping it does not remove the directory. try: - os.add_dll_directory(dirpath) # type: ignore[attr-defined] + if sys.platform == "win32": + os.add_dll_directory(dirpath) except OSError as e: # Warn instead of failing silently; the PATH update below is a weaker # fallback that newer loaders may ignore. @@ -96,7 +106,7 @@ def abs_path_for_dynamic_library(libname: str, handle: ctypes.wintypes.HMODULE) length = kernel32.GetModuleFileNameW(handle, buffer, len(buffer)) if length == 0: - error_code = ctypes.GetLastError() # type: ignore[attr-defined] + error_code = kernel32.GetLastError() raise RuntimeError(f"GetModuleFileNameW failed for {libname!r} (error code: {error_code})") # If buffer was too small, try with larger buffer @@ -104,7 +114,7 @@ def abs_path_for_dynamic_library(libname: str, handle: ctypes.wintypes.HMODULE) buffer = ctypes.create_unicode_buffer(32768) # Extended path length length = kernel32.GetModuleFileNameW(handle, buffer, len(buffer)) if length == 0: - error_code = ctypes.GetLastError() # type: ignore[attr-defined] + error_code = kernel32.GetLastError() raise RuntimeError(f"GetModuleFileNameW failed for {libname!r} (error code: {error_code})") return buffer.value @@ -170,7 +180,7 @@ def load_with_abs_path(desc: LibDescriptor, found_path: str, found_via: str | No handle = kernel32.LoadLibraryExW(found_path, None, flags) if not handle: - error_code = ctypes.GetLastError() # type: ignore[attr-defined] + error_code = kernel32.GetLastError() raise RuntimeError(f"Failed to load DLL at {found_path}: Windows error {error_code}") return LoadedDL(found_path, False, ctypes_handle_to_unsigned_int(handle), found_via) diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/platform_loader.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/platform_loader.py index 9b108a57acc..64bf55efe3d 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/platform_loader.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/platform_loader.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 """Platform loader seam for OS-specific dynamic linking. @@ -16,11 +16,11 @@ from __future__ import annotations +import sys from typing import Protocol from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL -from cuda.pathfinder._utils.platform_aware import IS_WINDOWS class PlatformLoader(Protocol): @@ -31,7 +31,7 @@ def load_with_system_search(self, desc: LibDescriptor) -> LoadedDL | None: ... def load_with_abs_path(self, desc: LibDescriptor, found_path: str, found_via: str | None = None) -> LoadedDL: ... -if IS_WINDOWS: +if sys.platform == "win32": from cuda.pathfinder._dynamic_libs import load_dl_windows as _impl else: from cuda.pathfinder._dynamic_libs import load_dl_linux as _impl diff --git a/cuda_pathfinder/cuda/pathfinder/_utils/driver_info.py b/cuda_pathfinder/cuda/pathfinder/_utils/driver_info.py index a5d4d167d33..d07c4b861d3 100644 --- a/cuda_pathfinder/cuda/pathfinder/_utils/driver_info.py +++ b/cuda_pathfinder/cuda/pathfinder/_utils/driver_info.py @@ -5,13 +5,13 @@ import ctypes import functools +import sys from collections.abc import Callable from dataclasses import dataclass from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import ( load_nvidia_dynamic_lib as _load_nvidia_dynamic_lib, ) -from cuda.pathfinder._utils.platform_aware import IS_WINDOWS class QueryDriverCudaVersionError(RuntimeError): @@ -60,16 +60,16 @@ def query_driver_cuda_version() -> DriverCudaVersion: raise QueryDriverCudaVersionError("Failed to query the CUDA driver version.") from exc +if sys.platform == "win32": + _DRIVER_LIB_LOADER: Callable[[str], ctypes.CDLL] = ctypes.WinDLL +else: + _DRIVER_LIB_LOADER = ctypes.CDLL + + def _query_driver_cuda_version_int() -> int: """Return the encoded CUDA driver version from ``cuDriverGetVersion()``.""" loaded_cuda = _load_nvidia_dynamic_lib("cuda") - if IS_WINDOWS: - # `ctypes.WinDLL` exists on Windows at runtime. The ignore is only for - # Linux mypy runs, where the platform stubs do not define that attribute. - loader_cls: Callable[[str], ctypes.CDLL] = ctypes.WinDLL # type: ignore[attr-defined] - else: - loader_cls = ctypes.CDLL - driver_lib = loader_cls(loaded_cuda.abs_path) + driver_lib = _DRIVER_LIB_LOADER(loaded_cuda.abs_path) cu_driver_get_version = driver_lib.cuDriverGetVersion cu_driver_get_version.argtypes = [ctypes.POINTER(ctypes.c_int)] cu_driver_get_version.restype = ctypes.c_int diff --git a/cuda_pathfinder/tests/test_utils_driver_info.py b/cuda_pathfinder/tests/test_utils_driver_info.py index 21948dadafe..0b3cd61d299 100644 --- a/cuda_pathfinder/tests/test_utils_driver_info.py +++ b/cuda_pathfinder/tests/test_utils_driver_info.py @@ -46,7 +46,6 @@ def test_query_driver_cuda_version_uses_windll_on_windows(monkeypatch): fake_driver_lib = _FakeDriverLib(status=0, version=12080) loaded_paths: list[str] = [] - monkeypatch.setattr(driver_info, "IS_WINDOWS", True) monkeypatch.setattr( driver_info, "_load_nvidia_dynamic_lib", @@ -57,7 +56,7 @@ def fake_windll(abs_path: str): loaded_paths.append(abs_path) return fake_driver_lib - monkeypatch.setattr(driver_info.ctypes, "WinDLL", fake_windll, raising=False) + monkeypatch.setattr(driver_info, "_DRIVER_LIB_LOADER", fake_windll) assert driver_info._query_driver_cuda_version_int() == 12080 assert loaded_paths == [r"C:\Windows\System32\nvcuda.dll"] @@ -93,9 +92,8 @@ def fail_query_driver_cuda_version_int() -> int: def test_query_driver_cuda_version_int_raises_when_cuda_call_fails(monkeypatch): fake_driver_lib = _FakeDriverLib(status=1, version=0) - monkeypatch.setattr(driver_info, "IS_WINDOWS", False) monkeypatch.setattr(driver_info, "_load_nvidia_dynamic_lib", lambda _libname: _loaded_cuda("/usr/lib/libcuda.so.1")) - monkeypatch.setattr(driver_info.ctypes, "CDLL", lambda _abs_path: fake_driver_lib) + monkeypatch.setattr(driver_info, "_DRIVER_LIB_LOADER", lambda _abs_path: fake_driver_lib) with pytest.raises(RuntimeError, match=r"cuDriverGetVersion\(\) \(status=1\)"): driver_info._query_driver_cuda_version_int() diff --git a/toolshed/run_stubgen_pyx.py b/toolshed/run_stubgen_pyx.py new file mode 100644 index 00000000000..1a163ff0778 --- /dev/null +++ b/toolshed/run_stubgen_pyx.py @@ -0,0 +1,54 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Run stubgen-pyx for cuda_core and normalize the generated stub headers. + +stubgen-pyx emits a path using the OS path separator in the first-line comment +(e.g. "# This file was generated by stubgen-pyx from cuda_core\\cuda\\..."). +This wrapper rewrites that separator to "/" so committed stubs are identical +across platforms. Line-ending normalization is handled by .gitattributes. + +This also forces stubgen-pyx to write files with UTF-8 encoding, which is not +the default on Windows. + +This wrapper can be removed once these stubgen-pyx issues are resolved: + https://github.com/jon-edward/stubgen-pyx/issues/41 + https://github.com/jon-edward/stubgen-pyx/issues/42 +""" + +from __future__ import annotations + +import os +import pathlib +import subprocess +import sys + +_HEADER_PREFIX = b"# This file was generated by stubgen-pyx" + + +def _normalize_stub_headers(root: pathlib.Path) -> None: + for stub in root.rglob("*.pyi"): + data = stub.read_bytes() + newline = data.find(b"\n") + first_line = data[:newline] if newline != -1 else data + if not first_line.startswith(_HEADER_PREFIX) or b"\\" not in first_line: + continue + stub.write_bytes(first_line.replace(b"\\", b"/") + data[newline:]) + + +def main() -> int: + env = os.environ.copy() + env.setdefault("PYTHONUTF8", "1") + env.setdefault("PYTHONIOENCODING", "utf-8") + result = subprocess.run( + ["stubgen-pyx", "cuda_core/cuda", "--continue-on-error", "--include-private"], # noqa: S607 + env=env, + ) + if result.returncode != 0: + return result.returncode + _normalize_stub_headers(pathlib.Path("cuda_core/cuda")) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) From 17e2749f1ff17b0204e5b4b45810bff0f02757de Mon Sep 17 00:00:00 2001 From: Sebastian Berg Date: Sun, 2 Aug 2026 17:43:15 +0200 Subject: [PATCH 19/50] Bumpy cython dependency to 2.3.5 (#2469) As Keith noted, this is needed for using the `py_safe_call_once` definitions, Cython 3.2.5 changelog: https://cython.readthedocs.io/en/latest/src/changes.html (I guess the bump in the pre-commit is likely not strictly needed, but there also were no stub changes.) --- .pre-commit-config.yaml | 2 +- cuda_bindings/pixi.lock | 166 ++----- cuda_bindings/pixi.toml | 6 +- cuda_bindings/pyproject.toml | 4 +- cuda_core/pixi.lock | 683 +++++++++++++------------- cuda_core/pixi.toml | 6 +- cuda_core/pyproject.toml | 4 +- cuda_pathfinder/pixi.lock | 40 +- cuda_pathfinder/pixi.toml | 2 +- cuda_python/docs/environment-docs.yml | 2 +- toolshed/setup-docs-env.sh | 4 +- 11 files changed, 413 insertions(+), 506 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d7453873566..d677b7ea7fe 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -75,7 +75,7 @@ repos: pass_filenames: false additional_dependencies: - stubgen-pyx==0.2.6 - - Cython==3.2.4 + - Cython==3.2.9 # Link checking for authored documentation files - repo: https://github.com/lycheeverse/lychee diff --git a/cuda_bindings/pixi.lock b/cuda_bindings/pixi.lock index 65cb1f78793..1cab16dd77a 100644 --- a/cuda_bindings/pixi.lock +++ b/cuda_bindings/pixi.lock @@ -37,7 +37,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.9.86-h4bc722e_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.9.86-h4bc722e_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.9.79-h7938cbb_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-8.0.1-gpl_hcddb375_914.conda @@ -238,7 +238,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-12.9.86-h7b14b0b_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-12.9.86-h7b14b0b_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-12.9.79-h16bee8c_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py314h4c416a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ffmpeg-8.0.1-gpl_h62efc85_914.conda @@ -469,7 +469,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-12.9.86-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-12.9.86-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-profiler-api-12.9.79-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.0.1-gpl_hb2d76f6_914.conda - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.17.1-hd47e2ca_0.conda @@ -574,7 +574,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.33-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.33-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-8.0.1-gpl_hb3f9226_906.conda @@ -767,7 +767,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.33-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.33-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py314h4c416a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ffmpeg-8.0.1-gpl_h936a714_906.conda @@ -990,7 +990,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.33-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-13.3.33-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-profiler-api-13.3.27-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.0.1-gpl_h74fd8f1_908.conda - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.15.0-h765892d_1.conda @@ -1089,7 +1089,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.73-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.73-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.3-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-8.0.1-gpl_hb3f9226_906.conda @@ -1282,7 +1282,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.73-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.3-py314h4c416a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ffmpeg-8.0.1-gpl_h936a714_906.conda @@ -1505,7 +1505,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-12.9.86-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-12.9.86-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-profiler-api-12.9.79-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.3-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.0.1-gpl_h74fd8f1_907.conda - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.15.0-h765892d_1.conda @@ -1597,7 +1597,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-bindings-13.2.0-py312hf79963d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-13.3.33-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.33-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py312h68e6be4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.9-py312h68e6be4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.20-py312h8285ef7_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/greenlet-3.3.2-py312h8285ef7_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda @@ -1772,7 +1772,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-13.2.0-py312hdc0efb6_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-13.3.33-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.33-h7b14b0b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py312he940de5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py312hbda70bc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/debugpy-1.8.20-py312hf55c4e8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/greenlet-3.3.2-py312hf55c4e8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda @@ -2059,7 +2059,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-13.2.0-py312hc128f0a_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-13.3.33-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.33-h2466b09_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py312hd245ac3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py312hd245ac3_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/debugpy-1.8.20-py312ha1a9051_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/greenlet-3.3.2-py312ha1a9051_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h0ea6238_0.conda @@ -2639,9 +2639,9 @@ packages: run_exports: {} size: 25007 timestamp: 1779913616712 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.3-py314h1807b08_0.conda - sha256: a0e2ed0efefb82278e0fd1d455d10d1095d951a896591838b30674aa872300c4 - md5: f0658a93053b13335be941289d7d6160 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda + sha256: f0210259007f573e38f7b8037be9b36e53aa0906b786e9f1f931e0a24f8a18e6 + md5: 0e6a14f60b561b2fff81d325b4dc8283 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 @@ -2650,11 +2650,12 @@ packages: - python_abi 3.14.* *_cp314 license: Apache-2.0 license_family: APACHE - size: 3797747 - timestamp: 1765651158436 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py312h68e6be4_0.conda - sha256: 01b815091e0c534a5f32a830b514e31c150dc2f539b7ba1d5c70b6d095a5ebcf - md5: 14f638dad5953c83443a2c4f011f1c9e + run_exports: {} + size: 3819412 + timestamp: 1782821647528 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.9-py312h68e6be4_0.conda + sha256: 13e37a868e52933951b3f80fd5fe953742804499f2ee2b9a123e74070c265c0d + md5: 7311d3a6721eec7d76f4a84045f1ddfd depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 @@ -2665,35 +2666,9 @@ packages: license_family: APACHE purls: - pkg:pypi/cython?source=hash-mapping - size: 3738170 - timestamp: 1767577770165 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py314h1807b08_0.conda - sha256: f700d10c2a794710a1656a6fdb8908fb04f3c7812ac4f17187777646ede1a3d9 - md5: 866fd3d25b767bccb4adc8476f4035cd - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libstdcxx >=14 - - python >=3.14,<3.15.0a0 - - python_abi 3.14.* *_cp314 - license: Apache-2.0 - license_family: APACHE - size: 3806945 - timestamp: 1767576996860 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - sha256: f0210259007f573e38f7b8037be9b36e53aa0906b786e9f1f931e0a24f8a18e6 - md5: 0e6a14f60b561b2fff81d325b4dc8283 - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libstdcxx >=14 - - python >=3.14,<3.15.0a0 - - python_abi 3.14.* *_cp314 - license: Apache-2.0 - license_family: APACHE run_exports: {} - size: 3819412 - timestamp: 1782821647528 + size: 3731635 + timestamp: 1785016112258 - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda sha256: 22053a5842ca8ee1cf8e1a817138cdb5e647eb2c46979f84153f6ad7bde73020 md5: 418c6ca5929a611cbd69204907a83995 @@ -7148,60 +7123,34 @@ packages: run_exports: {} size: 25101 timestamp: 1779913642980 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.3-py314h4c416a3_0.conda - sha256: 431042164f0f50ce173be72d96f6a9ec069d1a4846f19ff8cf616ea98678a090 - md5: e641cbdecc93a5e243af87d198edc716 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda + sha256: 4add54f62b3fbdc7f8e1238f5e5990e16a561bed33d18e3dbc1db1d4f6cf8572 + md5: c8ec76477232c7e59f68545a1b4fb8ea depends: - libgcc >=14 - libstdcxx >=14 - python >=3.14,<3.15.0a0 - - python >=3.14,<3.15.0a0 *_cp314 - python_abi 3.14.* *_cp314 license: Apache-2.0 license_family: APACHE - size: 3701570 - timestamp: 1765651306767 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py312he940de5_0.conda - sha256: 30bfb6445b8ae8022996283faa2d918393b1f0f78e37014995e1733e50df4303 - md5: 2f50ec4afc8e9f402b9041e9cee62744 + run_exports: {} + size: 3747072 + timestamp: 1782821625037 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py312hbda70bc_0.conda + sha256: 9c3df78ef64fc05aaf01b4d16ccefe25656b7aac677a3a9d5e89e0c462c65a2c + md5: 30984003a6a35ea7b9eedc979cf52c7e depends: - libgcc >=14 - libstdcxx >=14 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/cython?source=hash-mapping - size: 3629503 - timestamp: 1767577211661 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py314h4c416a3_0.conda - sha256: 1369b5b23d9451ae3ef678cb68678778a6ea164186bc8ebe6539a1d6fa803da8 - md5: 822c83a4ba5a12101695ba39607c338f - depends: - - libgcc >=14 - - libstdcxx >=14 - - python >=3.14,<3.15.0a0 - - python >=3.14,<3.15.0a0 *_cp314 - - python_abi 3.14.* *_cp314 - license: Apache-2.0 - license_family: APACHE - size: 3707806 - timestamp: 1767577060898 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - sha256: 4add54f62b3fbdc7f8e1238f5e5990e16a561bed33d18e3dbc1db1d4f6cf8572 - md5: c8ec76477232c7e59f68545a1b4fb8ea - depends: - - libgcc >=14 - - libstdcxx >=14 - - python >=3.14,<3.15.0a0 - - python_abi 3.14.* *_cp314 - license: Apache-2.0 - license_family: APACHE run_exports: {} - size: 3747072 - timestamp: 1782821625037 + size: 3649707 + timestamp: 1785016066705 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda sha256: 33fe66d025cf5bac7745196d1a3dd7a437abcf2dbce66043e9745218169f7e17 md5: 6e5a87182d66b2d1328a96b61ca43a62 @@ -13825,9 +13774,9 @@ packages: run_exports: {} size: 25690 timestamp: 1779913686281 -- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.3-py314h344ed54_0.conda - sha256: 6406b67af71dc477f891e6380eb6021d012ea467635c432017f08f954fa2b98d - md5: 91e2ed41320f5c89cc6d77ef47a820cd +- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda + sha256: 8900c3a11e71521ed7400265a36686c4ed3973b937658c1f58cc74b707a1c173 + md5: 596f6f1a842a246dbe778dce002d0ca5 depends: - python >=3.14,<3.15.0a0 - python_abi 3.14.* *_cp314 @@ -13836,11 +13785,12 @@ packages: - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: APACHE - size: 3336844 - timestamp: 1765651351516 -- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py312hd245ac3_0.conda - sha256: 68e921fad16accb32e86c7c73abaea7d49c9346e078924d0a593f821672a5a0c - md5: 575ebca0d973015c21087b800bc48515 + run_exports: {} + size: 3338147 + timestamp: 1782821777709 +- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py312hd245ac3_0.conda + sha256: 277887d63842d6b9d8a49f6bde1c57149fd65342c85e1f3e2aa44402125d3115 + md5: 762f58961f768b8790a215a8521d33cd depends: - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 @@ -13851,35 +13801,9 @@ packages: license_family: APACHE purls: - pkg:pypi/cython?source=hash-mapping - size: 3285032 - timestamp: 1767577225362 -- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py314h344ed54_0.conda - sha256: c2e08246f2e6f38b5793ebc8d36de32704e4f152ed959ab0558d529580610e0e - md5: 545afbc1940d8a81f114b9c14eecf2ca - depends: - - python >=3.14,<3.15.0a0 - - python_abi 3.14.* *_cp314 - - ucrt >=10.0.20348.0 - - vc >=14.3,<15 - - vc14_runtime >=14.44.35208 - license: Apache-2.0 - license_family: APACHE - size: 3332872 - timestamp: 1767577440799 -- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda - sha256: 8900c3a11e71521ed7400265a36686c4ed3973b937658c1f58cc74b707a1c173 - md5: 596f6f1a842a246dbe778dce002d0ca5 - depends: - - python >=3.14,<3.15.0a0 - - python_abi 3.14.* *_cp314 - - ucrt >=10.0.20348.0 - - vc >=14.3,<15 - - vc14_runtime >=14.44.35208 - license: Apache-2.0 - license_family: APACHE run_exports: {} - size: 3338147 - timestamp: 1782821777709 + size: 3316549 + timestamp: 1785016176418 - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda sha256: 2aa2083c9c186da7d6f975ccfbef654ed54fff27f4bc321dbcd12cee932ec2c4 md5: ed2c27bda330e3f0ab41577cf8b9b585 diff --git a/cuda_bindings/pixi.toml b/cuda_bindings/pixi.toml index 943d57e11bb..2b566d12b1a 100644 --- a/cuda_bindings/pixi.toml +++ b/cuda_bindings/pixi.toml @@ -25,7 +25,7 @@ numpy = "*" [feature.docs.dependencies] cuda-bindings = "13.2.*" python = "3.12.*" -cython = "*" +cython = ">=3.2.5,<3.3" enum_tools = "*" make = "*" myst-nb = "*" @@ -41,7 +41,7 @@ sphinx-copybutton = "*" sphinx-toolbox = "*" [feature.cython-tests.dependencies] -cython = ">=3.2,<3.3" # for tests that exercise APIs from cython +cython = ">=3.2.5,<3.3" # for tests that exercise APIs from cython setuptools = "*" # for distutils gxx = "*" # to compile the generated code # These are necessary because running the Cython tests requires compiling @@ -115,7 +115,7 @@ python = "*" cuda-version = "*" setuptools = ">=80" setuptools-scm = ">=8" -cython = ">=3.2,<3.3" +cython = ">=3.2.5,<3.3" cuda-pathfinder = { path = "../cuda_pathfinder" } cuda-cudart-static = "*" cuda-nvrtc-dev = "*" diff --git a/cuda_bindings/pyproject.toml b/cuda_bindings/pyproject.toml index 9744a0a009b..1f6c9393ea3 100644 --- a/cuda_bindings/pyproject.toml +++ b/cuda_bindings/pyproject.toml @@ -4,7 +4,7 @@ requires = [ "setuptools>=80.0.0", "setuptools_scm[simple]>=8,!=10.1", - "cython>=3.2,<3.3", + "cython>=3.2.5,<3.3", "cuda-pathfinder>=1.5", ] build-backend = "build_hooks" @@ -44,7 +44,7 @@ all = [ [dependency-groups] test = [ - "cython>=3.2,<3.3", + "cython>=3.2.5,<3.3", "setuptools>=80.0.0", # TODO: remove the Python 3.15 guard once 3.15 is officially supported "matplotlib>=3.5.0,<=3.10.9; python_version < '3.15'", diff --git a/cuda_core/pixi.lock b/cuda_core/pixi.lock index ebaf967facd..a987aeab986 100644 --- a/cuda_core/pixi.lock +++ b/cuda_core/pixi.lock @@ -64,7 +64,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.9.86-h4bc722e_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.9.86-h4bc722e_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.9.79-h7938cbb_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-8.0.1-gpl_hcddb375_914.conda @@ -224,6 +224,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.9.86-ha770c72_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.4.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -255,7 +256,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-core[2472945f] @ . + - conda_source: cuda-core[5f946272] @ . linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -277,7 +278,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-12.9.86-h7b14b0b_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-12.9.86-h7b14b0b_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-12.9.79-h16bee8c_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py314h4c416a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ffmpeg-8.0.1-gpl_h62efc85_914.conda @@ -429,6 +430,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-12.9.86-h579c4fd_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.4.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -459,7 +461,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-core[491c4fa3] @ . + - conda_source: cuda-core[70e83c84] @ . win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/backports.strenum-1.3.1-haf276df_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda @@ -474,6 +476,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-12.9.86-h57928b3_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.4.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -524,7 +527,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-dev-12.9.86-hac47afa_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-12.9.86-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-12.9.86-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.0.1-gpl_hb2d76f6_914.conda - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.17.1-hd47e2ca_0.conda @@ -608,7 +611,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-core[8e8d43e1] @ . + - conda_source: cuda-core[5159f177] @ . cu13: channels: - url: https://conda.anaconda.org/conda-forge/ @@ -629,7 +632,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.33-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.33-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-8.0.1-gpl_hcddb375_914.conda @@ -787,6 +790,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.33-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -817,9 +821,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[29afc263] @ ../cuda_bindings - - conda_source: cuda-core[496050ab] @ . - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder + - conda_source: cuda-bindings[91169b48] @ ../cuda_bindings + - conda_source: cuda-core[83c371ca] @ . + - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -836,7 +840,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.33-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.33-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py314h4c416a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ffmpeg-8.0.1-gpl_h62efc85_914.conda @@ -986,6 +990,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.33-h579c4fd_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -1015,9 +1020,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[b73e05e0] @ ../cuda_bindings - - conda_source: cuda-core[b9ba9726] @ . - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder + - conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings + - conda_source: cuda-core[29d2d05a] @ . + - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/backports.strenum-1.3.1-haf276df_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda @@ -1030,6 +1035,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-13.3.33-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -1073,7 +1079,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-13.3.33-h719f0c7_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.33-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-13.3.33-h2466b09_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.0.1-gpl_hb2d76f6_914.conda - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.17.1-hd47e2ca_0.conda @@ -1157,9 +1163,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[1a320ca0] @ ../cuda_bindings - - conda_source: cuda-core[f1ea05b3] @ . - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder + - conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings + - conda_source: cuda-core[e56c61a7] @ . + - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder default: channels: - url: https://conda.anaconda.org/conda-forge/ @@ -1180,7 +1186,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.33-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.33-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-8.0.1-gpl_hcddb375_914.conda @@ -1338,6 +1344,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.33-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -1368,9 +1375,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[29afc263] @ ../cuda_bindings - - conda_source: cuda-core[496050ab] @ . - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder + - conda_source: cuda-bindings[91169b48] @ ../cuda_bindings + - conda_source: cuda-core[83c371ca] @ . + - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -1387,7 +1394,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.33-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.33-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py314h4c416a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ffmpeg-8.0.1-gpl_h62efc85_914.conda @@ -1537,6 +1544,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.33-h579c4fd_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -1566,9 +1574,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[b73e05e0] @ ../cuda_bindings - - conda_source: cuda-core[b9ba9726] @ . - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder + - conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings + - conda_source: cuda-core[29d2d05a] @ . + - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/backports.strenum-1.3.1-haf276df_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda @@ -1581,6 +1589,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-13.3.33-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -1624,7 +1633,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-13.3.33-h719f0c7_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.33-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-13.3.33-h2466b09_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.0.1-gpl_hb2d76f6_914.conda - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.17.1-hd47e2ca_0.conda @@ -1708,9 +1717,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[1a320ca0] @ ../cuda_bindings - - conda_source: cuda-core[f1ea05b3] @ . - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder + - conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings + - conda_source: cuda-core[e56c61a7] @ . + - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder docs: channels: - url: https://conda.anaconda.org/conda-forge/ @@ -1726,7 +1735,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-13.3.33-h69a702a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.33-h4bc722e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.33-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.20-py314h42812f9_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/greenlet-3.3.2-py314h42812f9_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda @@ -1894,9 +1903,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.6.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[29afc263] @ ../cuda_bindings - - conda_source: cuda-core[496050ab] @ . - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder + - conda_source: cuda-bindings[91169b48] @ ../cuda_bindings + - conda_source: cuda-core[83c371ca] @ . + - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder - pypi: https://files.pythonhosted.org/packages/8c/79/017fab2f7167a9a9795665f894d04f77aafceca80821b51589bb4b23ff5c/nvidia_sphinx_theme-0.0.9.post1-py3-none-any.whl linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda @@ -1907,7 +1916,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-13.3.33-he9431aa_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.33-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.33-h7b14b0b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py314h4c416a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/debugpy-1.8.20-py314he6363bd_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/greenlet-3.3.2-py314he6363bd_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda @@ -2076,9 +2085,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.6.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[b73e05e0] @ ../cuda_bindings - - conda_source: cuda-core[b9ba9726] @ . - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder + - conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings + - conda_source: cuda-core[29d2d05a] @ . + - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder - pypi: https://files.pythonhosted.org/packages/8c/79/017fab2f7167a9a9795665f894d04f77aafceca80821b51589bb4b23ff5c/nvidia_sphinx_theme-0.0.9.post1-py3-none-any.whl win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda @@ -2200,7 +2209,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-13.3.33-h719f0c7_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.33-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-13.3.33-h2466b09_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/debugpy-1.8.20-py314hb98de8c_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/greenlet-3.3.2-py314hb98de8c_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h0ea6238_0.conda @@ -2246,9 +2255,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h6a83c73_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zeromq-4.3.5-h507cc87_10.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[1a320ca0] @ ../cuda_bindings - - conda_source: cuda-core[f1ea05b3] @ . - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder + - conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings + - conda_source: cuda-core[e56c61a7] @ . + - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder - pypi: https://files.pythonhosted.org/packages/8c/79/017fab2f7167a9a9795665f894d04f77aafceca80821b51589bb4b23ff5c/nvidia_sphinx_theme-0.0.9.post1-py3-none-any.whl examples: channels: @@ -2478,9 +2487,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - - conda_source: cuda-bindings[29afc263] @ ../cuda_bindings - - conda_source: cuda-core[496050ab] @ . - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder + - conda_source: cuda-bindings[91169b48] @ ../cuda_bindings + - conda_source: cuda-core[83c371ca] @ . + - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder p2: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-7_kmp_llvm.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -2699,9 +2708,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-h396c80c_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - - conda_source: cuda-bindings[b73e05e0] @ ../cuda_bindings - - conda_source: cuda-core[b9ba9726] @ . - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder + - conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings + - conda_source: cuda-core[29d2d05a] @ . + - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder p3: - conda: https://conda.anaconda.org/conda-forge/noarch/backports.strenum-1.3.1-haf276df_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda @@ -2797,9 +2806,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[1a320ca0] @ ../cuda_bindings - - conda_source: cuda-core[f1ea05b3] @ . - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder + - conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings + - conda_source: cuda-core[e56c61a7] @ . + - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder numba-classic: channels: - url: https://conda.anaconda.org/conda-forge/ @@ -4317,21 +4326,6 @@ packages: license_family: MIT size: 33970282 timestamp: 1771604499034 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py314h1807b08_0.conda - sha256: f700d10c2a794710a1656a6fdb8908fb04f3c7812ac4f17187777646ede1a3d9 - md5: 866fd3d25b767bccb4adc8476f4035cd - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libstdcxx >=14 - - python >=3.14,<3.15.0a0 - - python_abi 3.14.* *_cp314 - license: Apache-2.0 - license_family: APACHE - purls: - - pkg:pypi/cython?source=hash-mapping - size: 3806945 - timestamp: 1767576996860 - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda sha256: f0210259007f573e38f7b8037be9b36e53aa0906b786e9f1f931e0a24f8a18e6 md5: 0e6a14f60b561b2fff81d325b4dc8283 @@ -4343,6 +4337,8 @@ packages: - python_abi 3.14.* *_cp314 license: Apache-2.0 license_family: APACHE + purls: + - pkg:pypi/cython?source=hash-mapping run_exports: {} size: 3819412 timestamp: 1782821647528 @@ -9643,34 +9639,21 @@ packages: license_family: MIT size: 39128286 timestamp: 1771605119782 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py314h4c416a3_0.conda - sha256: 1369b5b23d9451ae3ef678cb68678778a6ea164186bc8ebe6539a1d6fa803da8 - md5: 822c83a4ba5a12101695ba39607c338f +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda + sha256: 84aebc300e4a0f4ea697d95ec97277301e83f0a457e61efb48b27a14cfb37bda + md5: 4a44c5167b358f22ae2cd89b07728797 depends: - libgcc >=14 - libstdcxx >=14 - python >=3.14,<3.15.0a0 - - python >=3.14,<3.15.0a0 *_cp314 - python_abi 3.14.* *_cp314 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/cython?source=hash-mapping - size: 3707806 - timestamp: 1767577060898 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - sha256: 4add54f62b3fbdc7f8e1238f5e5990e16a561bed33d18e3dbc1db1d4f6cf8572 - md5: c8ec76477232c7e59f68545a1b4fb8ea - depends: - - libgcc >=14 - - libstdcxx >=14 - - python >=3.14,<3.15.0a0 - - python_abi 3.14.* *_cp314 - license: Apache-2.0 - license_family: APACHE run_exports: {} - size: 3747072 - timestamp: 1782821625037 + size: 3741802 + timestamp: 1785016071504 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda sha256: 33fe66d025cf5bac7745196d1a3dd7a437abcf2dbce66043e9745218169f7e17 md5: 6e5a87182d66b2d1328a96b61ca43a62 @@ -14592,6 +14575,17 @@ packages: - pkg:pypi/docutils?source=hash-mapping size: 402700 timestamp: 1733217860944 +- conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.23-pyhcf101f3_0.conda + sha256: def3b2566a1702fa083a8984753ac0b3e3f7381048f88714e03d55b7bd930b74 + md5: 2c3958e02221c2504ec036139e648d8b + depends: + - python >=3.10 + - python + license: LGPL-3.0-only + license_family: LGPL + run_exports: {} + size: 459540 + timestamp: 1779967837277 - conda: https://conda.anaconda.org/conda-forge/noarch/domdf-python-tools-3.10.0-pyhff2d567_0.conda sha256: e7a7121de51caa332e73a0a7345d78fb514a8460311347be5d8eba0738c66c31 md5: 0254332c3957f0ae09a58670c2d7ea01 @@ -16976,9 +16970,9 @@ packages: run_exports: {} size: 25690 timestamp: 1779913686281 -- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py314h344ed54_0.conda - sha256: c2e08246f2e6f38b5793ebc8d36de32704e4f152ed959ab0558d529580610e0e - md5: 545afbc1940d8a81f114b9c14eecf2ca +- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda + sha256: a061170102d6f1a0b64ed3be712ac653fd9c9e8b6bed6205f398dbf319dcc3c8 + md5: 8ecd457018d6f302da0945cd2169167d depends: - python >=3.14,<3.15.0a0 - python_abi 3.14.* *_cp314 @@ -16989,22 +16983,9 @@ packages: license_family: APACHE purls: - pkg:pypi/cython?source=hash-mapping - size: 3332872 - timestamp: 1767577440799 -- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda - sha256: 8900c3a11e71521ed7400265a36686c4ed3973b937658c1f58cc74b707a1c173 - md5: 596f6f1a842a246dbe778dce002d0ca5 - depends: - - python >=3.14,<3.15.0a0 - - python_abi 3.14.* *_cp314 - - ucrt >=10.0.20348.0 - - vc >=14.3,<15 - - vc14_runtime >=14.44.35208 - license: Apache-2.0 - license_family: APACHE run_exports: {} - size: 3338147 - timestamp: 1782821777709 + size: 3343814 + timestamp: 1785016211855 - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda sha256: 2aa2083c9c186da7d6f975ccfbef654ed54fff27f4bc321dbcd12cee932ec2c4 md5: ed2c27bda330e3f0ab41577cf8b9b585 @@ -19382,7 +19363,112 @@ packages: - zstd >=1.5.7,<1.6.0a0 size: 388453 timestamp: 1764777142545 -- conda_source: cuda-bindings[1a320ca0] @ ../cuda_bindings +- conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings + variants: + c_stdlib: sysroot + c_stdlib_version: '2.28' + cuda_version: 13.3.* + python: 3.14.* + target_platform: linux-aarch64 + depends: + - python + - python >=3.10 + - cuda-version + - cuda-pathfinder + - libnvjitlink + - cuda-nvrtc + - cuda-nvrtc >=13.3.33,<14.0a0 + - cuda-nvvm + - libnvfatbin + - libcufile + - libcufile >=1.18.1.6,<2.0a0 + - libgcc >=15 + - libgcc >=15 + - libstdcxx >=15 + - __glibc >=2.28,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + source_depends: + cuda-pathfinder: + path: ../cuda_pathfinder + build_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-dev-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-13.3.73-he9431aa_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.73-h7b14b0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-dev-1.18.1.6-he38c790_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.73-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda + - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder +- conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings variants: c_compiler: vs2022 cuda_version: 13.3.* @@ -19437,7 +19523,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.73-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-13.3.73-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-profiler-api-13.3.27-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda @@ -19453,8 +19539,8 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder -- conda_source: cuda-bindings[29afc263] @ ../cuda_bindings + - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder +- conda_source: cuda-bindings[91169b48] @ ../cuda_bindings variants: c_stdlib: sysroot c_stdlib_version: '2.28' @@ -19556,8 +19642,8 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder -- conda_source: cuda-bindings[b73e05e0] @ ../cuda_bindings + - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder +- conda_source: cuda-core[29d2d05a] @ . variants: c_stdlib: sysroot c_stdlib_version: '2.28' @@ -19568,23 +19654,18 @@ packages: - python - python >=3.10 - cuda-version + - numpy + - cuda-bindings - cuda-pathfinder - - libnvjitlink - - cuda-nvrtc - - cuda-nvrtc >=13.3.33,<14.0a0 - - cuda-nvvm - - libnvfatbin - - libcufile - - libcufile >=1.18.1.6,<2.0a0 + - backports.strenum - libgcc >=15 - libgcc >=15 - libstdcxx >=15 - __glibc >=2.28,<3.0.a0 - python_abi 3.14.* *_cp314 + - cuda-nvrtc >=13.3.33,<14.0a0 + - cuda-cudart >=13.3.29,<14.0a0 license: Apache-2.0 - source_depends: - cuda-pathfinder: - path: ../cuda_pathfinder build_packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda @@ -19608,21 +19689,21 @@ packages: host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-13.3.1-py314he6363bd_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-13.3.33-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-dev-13.3.33-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-13.3.73-he9431aa_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.73-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dlpack-1.3-hfae3067_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcudla-13.3.29-hfae3067_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-dev-1.18.1.6-he38c790_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda @@ -19630,6 +19711,8 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-13.3.33-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda @@ -19651,7 +19734,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.73-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda @@ -19661,8 +19744,83 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder -- conda_source: cuda-core[2472945f] @ . +- conda_source: cuda-core[5159f177] @ . + variants: + c_compiler: vs2022 + cuda_version: 12.* + cxx_compiler: vs2022 + python: 3.14.* + target_platform: win-64 + depends: + - python + - python >=3.10 + - cuda-version + - numpy + - cuda-bindings + - cuda-pathfinder + - backports.strenum + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + - cuda-nvrtc >=12.9.86,<13.0a0 + - cuda-cudart >=12.9.79,<13.0a0 + license: Apache-2.0 + build_packages: + - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-12.9.27-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_win-64-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_win-64-12.9.86-h36c15f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_win-64-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-12.9.7-py314h2547b3f_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-crt-tools-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-dev-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-static-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvcc-impl-12.9.86-h53cbb54_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvcc-tools-12.9.86-he0c23c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-12.9.86-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-dev-12.9.86-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-12.9.86-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-12.9.86-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/dlpack-1.3-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libnvjitlink-12.9.86-hac47afa_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libnvptxcompiler-dev-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda +- conda_source: cuda-core[5f946272] @ . variants: c_stdlib: sysroot c_stdlib_version: '2.28' @@ -19767,7 +19925,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda -- conda_source: cuda-core[491c4fa3] @ . +- conda_source: cuda-core[70e83c84] @ . variants: c_stdlib: sysroot c_stdlib_version: '2.28' @@ -19825,7 +19983,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-12.9.86-h7b14b0b_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-12.9.86-h7b14b0b_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-12.9.79-h16bee8c_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dlpack-1.3-hfae3067_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda @@ -19874,7 +20032,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda -- conda_source: cuda-core[496050ab] @ . +- conda_source: cuda-core[83c371ca] @ . variants: c_stdlib: sysroot c_stdlib_version: '2.28' @@ -19893,9 +20051,9 @@ packages: - libgcc >=15 - libstdcxx >=15 - __glibc >=2.28,<3.0.a0 - - cuda-cudart >=13.3.29,<14.0a0 - - cuda-nvrtc >=13.3.33,<14.0a0 - python_abi 3.14.* *_cp314 + - cuda-nvrtc >=13.3.33,<14.0a0 + - cuda-cudart >=13.3.29,<14.0a0 license: Apache-2.0 build_packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda @@ -19972,184 +20130,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda -- conda_source: cuda-core[8e8d43e1] @ . - variants: - c_compiler: vs2022 - cuda_version: 12.* - cxx_compiler: vs2022 - python: 3.14.* - target_platform: win-64 - depends: - - python - - python >=3.10 - - cuda-version - - numpy - - cuda-bindings - - cuda-pathfinder - - backports.strenum - - vc >=14.3,<15 - - vc14_runtime >=14.44.35208 - - ucrt >=10.0.20348.0 - - python_abi 3.14.* *_cp314 - - cuda-nvrtc >=12.9.86,<13.0a0 - - cuda-cudart >=12.9.79,<13.0a0 - license: Apache-2.0 - build_packages: - - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda - host_packages: - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-12.9.27-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-12.9.86-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_win-64-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_win-64-12.9.86-h36c15f3_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-12.9.86-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_win-64-12.9.86-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-12.9.7-py314h2547b3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-crt-tools-12.9.86-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-dev-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-static-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvcc-impl-12.9.86-h53cbb54_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvcc-tools-12.9.86-he0c23c2_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-12.9.86-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-dev-12.9.86-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-12.9.86-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-12.9.86-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/dlpack-1.3-hac47afa_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libnvjitlink-12.9.86-hac47afa_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libnvptxcompiler-dev-12.9.86-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda -- conda_source: cuda-core[b9ba9726] @ . - variants: - c_stdlib: sysroot - c_stdlib_version: '2.28' - cuda_version: 13.3.* - python: 3.14.* - target_platform: linux-aarch64 - depends: - - python - - python >=3.10 - - cuda-version - - numpy - - cuda-bindings - - cuda-pathfinder - - backports.strenum - - libgcc >=15 - - libgcc >=15 - - libstdcxx >=15 - - __glibc >=2.28,<3.0.a0 - - cuda-cudart >=13.3.29,<14.0a0 - - cuda-nvrtc >=13.3.33,<14.0a0 - - python_abi 3.14.* *_cp314 - license: Apache-2.0 - build_packages: - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - host_packages: - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-13.3.1-py314he6363bd_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-13.3.33-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-dev-13.3.33-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dlpack-1.3-hfae3067_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcudla-13.3.29-hfae3067_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-13.3.33-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda -- conda_source: cuda-core[f1ea05b3] @ . +- conda_source: cuda-core[e56c61a7] @ . variants: c_compiler: vs2022 cuda_version: 13.3.* @@ -20167,8 +20148,8 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 - ucrt >=10.0.20348.0 - - cuda-nvrtc >=13.3.33,<14.0a0 - python_abi 3.14.* *_cp314 + - cuda-nvrtc >=13.3.33,<14.0a0 license: Apache-2.0 build_packages: - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda @@ -20195,7 +20176,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-13.3.33-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-dev-13.3.33-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.73-h2466b09_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/dlpack-1.3-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda @@ -20214,7 +20195,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda -- conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder +- conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder variants: target_platform: noarch depends: @@ -20222,7 +20203,27 @@ packages: - python * license: Apache-2.0 host_packages: - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.11.29-h2112641_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda @@ -20231,23 +20232,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda -- conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder +- conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder variants: target_platform: noarch depends: @@ -20285,7 +20270,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda -- conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder +- conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder variants: target_platform: noarch depends: @@ -20293,27 +20278,7 @@ packages: - python * license: Apache-2.0 host_packages: - - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.11.29-h2112641_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda @@ -20322,6 +20287,22 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - pypi: https://files.pythonhosted.org/packages/01/8a/f767031dcd0d24c2bbab4b696dbcf004da4f3284e5e4649fc47bc0e2bb78/nvidia_nvvm-13.3.33-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl name: nvidia-nvvm version: 13.3.33 diff --git a/cuda_core/pixi.toml b/cuda_core/pixi.toml index 30767983ba1..3fcdfdffe88 100644 --- a/cuda_core/pixi.toml +++ b/cuda_core/pixi.toml @@ -53,7 +53,7 @@ CUDA_HOME = "$CONDA_PREFIX/targets/sbsa-linux" CUDA_HOME = "$CONDA_PREFIX/Library" [feature.cython-tests.dependencies] -cython = ">=3.2,<3.3" # for tests that exercise APIs from cython +cython = ">=3.2.5,<3.3" # for tests that exercise APIs from cython setuptools = "*" # for distutils gxx = "*" # to compile the generated code # These are necessary because running the Cython tests requires compiling @@ -94,7 +94,7 @@ cuda-version = "12.*" [feature.docs.dependencies] cuda-core = { path = "." } -cython = "*" +cython = ">=3.2.5,<3.3" myst-parser = "*" numpy = "*" numpydoc = "*" @@ -211,7 +211,7 @@ python = "*" cuda-version = "*" setuptools = ">=80" setuptools-scm = ">=8" -cython = ">=3.2,<3.3" +cython = ">=3.2.5,<3.3" cuda-nvrtc-dev = "*" cuda-bindings = "*" dlpack = "*" diff --git a/cuda_core/pyproject.toml b/cuda_core/pyproject.toml index 2c6435e4957..29e6b2a4bf9 100644 --- a/cuda_core/pyproject.toml +++ b/cuda_core/pyproject.toml @@ -6,7 +6,7 @@ requires = [ "setuptools>=80", "setuptools-scm[simple]>=8,!=10.1", - "Cython>=3.2,<3.3", + "Cython>=3.2.5,<3.3", "cuda-pathfinder>=1.5" ] build-backend = "build_hooks" @@ -59,7 +59,7 @@ cu13 = ["cuda-bindings[all]==13.*", "cuda-toolkit==13.*"] [dependency-groups] test = [ - "cython>=3.2,<3.3", + "cython>=3.2.5,<3.3", "setuptools>=80", "pytest==9.1.0", "pytest-benchmark==5.2.3", diff --git a/cuda_pathfinder/pixi.lock b/cuda_pathfinder/pixi.lock index 0891bddfece..bc46282b4ad 100644 --- a/cuda_pathfinder/pixi.lock +++ b/cuda_pathfinder/pixi.lock @@ -420,7 +420,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/backports.zstd-1.3.0-py312h90b7ffd_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.2.0-py312hdb49522_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py312h68e6be4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.9-py312h68e6be4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.20-py312h8285ef7_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/greenlet-3.3.2-py312h8285ef7_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda @@ -586,7 +586,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zstd-1.3.0-py312h3d8e7d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.2.0-py312hac7b6a9_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py312he940de5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py312hbda70bc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/debugpy-1.8.20-py312hf55c4e8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/greenlet-3.3.2-py312hf55c4e8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda @@ -863,7 +863,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/backports.zstd-1.3.0-py312h06d0912_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.2.0-py312hc6d9e41_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py312hd245ac3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py312hd245ac3_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/debugpy-1.8.20-py312ha1a9051_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/greenlet-3.3.2-py312ha1a9051_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h0ea6238_0.conda @@ -1003,9 +1003,9 @@ packages: - bzip2 >=1.0.8,<2.0a0 size: 260182 timestamp: 1771350215188 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.4-py312h68e6be4_0.conda - sha256: 01b815091e0c534a5f32a830b514e31c150dc2f539b7ba1d5c70b6d095a5ebcf - md5: 14f638dad5953c83443a2c4f011f1c9e +- conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.9-py312h68e6be4_0.conda + sha256: 13e37a868e52933951b3f80fd5fe953742804499f2ee2b9a123e74070c265c0d + md5: 7311d3a6721eec7d76f4a84045f1ddfd depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 @@ -1016,8 +1016,9 @@ packages: license_family: APACHE purls: - pkg:pypi/cython?source=hash-mapping - size: 3738170 - timestamp: 1767577770165 + run_exports: {} + size: 3731635 + timestamp: 1785016112258 - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.20-py312h8285ef7_0.conda sha256: f20121b67149ff80bf951ccae7442756586d8789204cd08ade59397b22bfd098 md5: ee1b48795ceb07311dd3e665dd4f5f33 @@ -2115,21 +2116,21 @@ packages: - bzip2 >=1.0.8,<2.0a0 size: 192412 timestamp: 1771350241232 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.4-py312he940de5_0.conda - sha256: 30bfb6445b8ae8022996283faa2d918393b1f0f78e37014995e1733e50df4303 - md5: 2f50ec4afc8e9f402b9041e9cee62744 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py312hbda70bc_0.conda + sha256: 9c3df78ef64fc05aaf01b4d16ccefe25656b7aac677a3a9d5e89e0c462c65a2c + md5: 30984003a6a35ea7b9eedc979cf52c7e depends: - libgcc >=14 - libstdcxx >=14 - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: Apache-2.0 license_family: APACHE purls: - pkg:pypi/cython?source=hash-mapping - size: 3629503 - timestamp: 1767577211661 + run_exports: {} + size: 3649707 + timestamp: 1785016066705 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/debugpy-1.8.20-py312hf55c4e8_0.conda sha256: c041ed2da3fd1e237972a360cb0f532a0caf66f571fdc9ec2cc07ccb48b8c665 md5: d7ee86593223e812e41612678c26a10d @@ -4959,9 +4960,9 @@ packages: - bzip2 >=1.0.8,<2.0a0 size: 56115 timestamp: 1771350256444 -- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.4-py312hd245ac3_0.conda - sha256: 68e921fad16accb32e86c7c73abaea7d49c9346e078924d0a593f821672a5a0c - md5: 575ebca0d973015c21087b800bc48515 +- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py312hd245ac3_0.conda + sha256: 277887d63842d6b9d8a49f6bde1c57149fd65342c85e1f3e2aa44402125d3115 + md5: 762f58961f768b8790a215a8521d33cd depends: - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 @@ -4972,8 +4973,9 @@ packages: license_family: APACHE purls: - pkg:pypi/cython?source=hash-mapping - size: 3285032 - timestamp: 1767577225362 + run_exports: {} + size: 3316549 + timestamp: 1785016176418 - conda: https://conda.anaconda.org/conda-forge/win-64/debugpy-1.8.20-py312ha1a9051_0.conda sha256: 5a886b1af3c66bf58213c7f3d802ea60fe8218313d9072bc1c9e8f7840548ba0 md5: 032746a0b0663920f0afb18cec61062b diff --git a/cuda_pathfinder/pixi.toml b/cuda_pathfinder/pixi.toml index 7ebcc9644d7..c38c08c3f2e 100644 --- a/cuda_pathfinder/pixi.toml +++ b/cuda_pathfinder/pixi.toml @@ -19,7 +19,7 @@ pytest-randomly = "*" # Keep this dependency set aligned with cuda_python/docs/environment-docs.yml. [feature.docs.dependencies] python = "3.12.*" -cython = "*" +cython = ">=3.2.5,<3.3" enum_tools = "*" make = "*" myst-nb = "*" diff --git a/cuda_python/docs/environment-docs.yml b/cuda_python/docs/environment-docs.yml index d6c5dde6c9b..3152f0a3a93 100644 --- a/cuda_python/docs/environment-docs.yml +++ b/cuda_python/docs/environment-docs.yml @@ -7,7 +7,7 @@ channels: dependencies: # ATTENTION: This dependency list is duplicated in # toolshed/setup-docs-env.sh. Please KEEP THEM IN SYNC! - - cython + - cython >=3.2.5,<3.3 - myst-parser - numpy - numpydoc diff --git a/toolshed/setup-docs-env.sh b/toolshed/setup-docs-env.sh index 16378725e93..9acbaa8e391 100755 --- a/toolshed/setup-docs-env.sh +++ b/toolshed/setup-docs-env.sh @@ -1,6 +1,6 @@ #!/usr/bin/env bash -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # Setup a local conda environment for building the sphinx docs to mirror the CI environment @@ -39,7 +39,7 @@ echo "Creating environment '${ENV_NAME}'…" # cuda_python/docs/environment-docs.yml. Please KEEP THEM IN SYNC! conda create -y -n "${ENV_NAME}" \ "python=${PYVER}" \ - cython \ + "cython>=3.2.5,<3.3" \ myst-parser \ numpy \ numpydoc \ From 51141c8531263c0a1fe013b82910eec16a9a2566 Mon Sep 17 00:00:00 2001 From: Tirth Patel Date: Mon, 3 Aug 2026 18:09:32 +0530 Subject: [PATCH 20/50] ci: drop custom NumPy and use beta 4 for Python 3.15 (#2411) * ci: drop custom NumPy builds for Python 3.15 Signed-off-by: tirthpatel90 * ci: enable scientific-python-nightly-wheels index for Python 3.15 Signed-off-by: tirthpatel90 * ci: set PIP_ONLY_BINARY and relax numpy version pin for Python 3.15 Signed-off-by: tirthpatel90 * Fix NumPy version in pyproject.toml and try re-adding windows python 3.15 * Bump cibuildwheel to 4.1.1 (which uses containers with 3.15 b4) * Revert "Use Python 3.15b2 for now until cibuildwheel is updated (#2433)" This reverts commit 3ef82d6892d27cd81b9f3f675a00cfc34b9b90d8. * Add allow-prereleases to windows CI to try and run 3.15 * Exclude ml-dtypes from windows (builds in 1 minute on linux so kept it) * Drop windows 3.15t again as psutil doesn't have free-threaded wheels --------- Signed-off-by: tirthpatel90 Co-authored-by: Sebastian Berg --- .github/workflows/build-wheel.yml | 77 ++++-------------------- .github/workflows/test-wheel-linux.yml | 25 +++----- .github/workflows/test-wheel-windows.yml | 27 +++------ ci/test-matrix.yml | 1 + cuda_bindings/pyproject.toml | 3 +- cuda_core/pyproject.toml | 3 +- 6 files changed, 33 insertions(+), 103 deletions(-) diff --git a/.github/workflows/build-wheel.yml b/.github/workflows/build-wheel.yml index d8a34baaf13..68f2801fb60 100644 --- a/.github/workflows/build-wheel.yml +++ b/.github/workflows/build-wheel.yml @@ -166,7 +166,7 @@ jobs: cuda-version: ${{ inputs.cuda-version }} - name: Build cuda.bindings wheel - uses: pypa/cibuildwheel@294735312765b09d24a2fbec22660ce817587d55 # v4.1.0 + uses: pypa/cibuildwheel@4726cd35bb13f7bde50cf2761f2499ac7b3aa32c # v4.1.1 with: package-dir: ./cuda_bindings/ output-dir: ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }} @@ -234,7 +234,7 @@ jobs: if-no-files-found: error - name: Build cuda.core wheel - uses: pypa/cibuildwheel@294735312765b09d24a2fbec22660ce817587d55 # v4.1.0 + uses: pypa/cibuildwheel@4726cd35bb13f7bde50cf2761f2499ac7b3aa32c # v4.1.1 with: package-dir: ./cuda_core/ output-dir: ${{ env.CUDA_CORE_ARTIFACTS_DIR }} @@ -338,13 +338,16 @@ jobs: id: setup-python2 uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 with: - # TODO: Pin beta.2 precisely until cibuildwheel catches up (b4 broke ABI for Cython); - # this precise pin requires the explicit `freethreaded`. - # When 3.15 is officially supported we can also remove the `allow-prereleases` override. - python-version: ${{ startsWith(matrix.python-version, '3.15') && '3.15.0-beta.2' || matrix.python-version }} - freethreaded: ${{ endsWith(matrix.python-version, 't') }} + python-version: ${{ matrix.python-version }} + # TODO: remove allow-prereleases once 3.15 is officially supported allow-prereleases: ${{ startsWith(matrix.python-version, '3.15') }} + - name: Enable Scientific Python Nightly Wheels for Python 3.15 + if: ${{ startsWith(matrix.python-version, '3.15') }} + run: | + echo "PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple" >> "$GITHUB_ENV" + echo "PIP_ONLY_BINARY=numpy" >> "$GITHUB_ENV" + - name: verify free-threaded build if: endsWith(matrix.python-version, 't') run: python -c 'import sys; assert not sys._is_gil_enabled()' @@ -370,64 +373,6 @@ jobs: mv "/c/Program Files/Git/usr/bin/link.exe" "/c/Program Files/Git/usr/bin/link.exe.bak" fi - # TODO: remove the numpy pre-build steps once 3.15 is officially supported - # (numpy will publish pre-built 3.15 wheels at that point) - - name: Download and patch numpy sdist (pre-release Python) - if: ${{ startsWith(matrix.python-version, '3.15') }} - run: | - pip download --no-binary numpy --no-deps "numpy>=1.21.1" -d numpy-sdist/ - cd numpy-sdist && tar xf numpy-*.tar.gz && rm numpy-*.tar.gz - # WAR: numpy 2.4.x ships [tool.cibuildwheel] config that is - # incompatible with cibuildwheel v4.0 (cpython-freethreading enable - # group, OpenBLAS before-build scripts, etc.). Strip the cibuildwheel - # sections but preserve [tool.meson-python] (vendored meson path). - python -c " - import glob - for f in glob.glob('numpy-*/pyproject.toml'): - lines, skip = open(f).readlines(), False - out = [] - for line in lines: - hdr = line.strip() - if hdr.startswith('[tool.cibuildwheel') or hdr.startswith('[[tool.cibuildwheel'): - skip = True - continue - if skip and hdr.startswith('[') and 'cibuildwheel' not in hdr: - skip = False - if not skip: - out.append(line) - open(f, 'w').writelines(out) - " - echo "NUMPY_SRC_DIR=$(pwd)/$(ls -d numpy-*/)" >> $GITHUB_ENV - - - name: Build numpy wheel (pre-release Python) - if: ${{ startsWith(matrix.python-version, '3.15') }} - uses: pypa/cibuildwheel@294735312765b09d24a2fbec22660ce817587d55 # v4.1.0 - env: - CIBW_BUILD: ${{ env.CIBW_BUILD }} - CIBW_SKIP: "*-musllinux* *-win32" - CIBW_ARCHS_LINUX: "native" - CIBW_BUILD_VERBOSITY: 1 - CIBW_CONFIG_SETTINGS: "setup-args=-Dallow-noblas=true" - CIBW_CONFIG_SETTINGS_WINDOWS: "setup-args=--vsenv setup-args=-Dallow-noblas=true" - CIBW_BEFORE_BUILD_WINDOWS: "pip install delvewheel" - CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: "delvewheel repair -w {dest_dir} {wheel}" - CIBW_ENABLE: "cpython-prerelease" - with: - package-dir: ${{ env.NUMPY_SRC_DIR }} - output-dir: numpy-wheel/ - - - name: Upload numpy wheel - if: ${{ startsWith(matrix.python-version, '3.15') }} - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 - with: - name: numpy-python${{ env.PYTHON_VERSION_FORMATTED }}-${{ inputs.host-platform }} - path: numpy-wheel/*.whl - if-no-files-found: error - - - name: Install numpy wheel - if: ${{ startsWith(matrix.python-version, '3.15') }} - run: pip install numpy-wheel/*.whl - - name: Build cuda.bindings Cython tests run: | pip install ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}/*.whl --group ./cuda_bindings/pyproject.toml:test @@ -508,7 +453,7 @@ jobs: rmdir $OLD_BASENAME - name: Build cuda.core wheel - uses: pypa/cibuildwheel@294735312765b09d24a2fbec22660ce817587d55 # v4.1.0 + uses: pypa/cibuildwheel@4726cd35bb13f7bde50cf2761f2499ac7b3aa32c # v4.1.1 with: package-dir: ./cuda_core/ output-dir: ${{ env.CUDA_CORE_ARTIFACTS_DIR }} diff --git a/.github/workflows/test-wheel-linux.yml b/.github/workflows/test-wheel-linux.yml index 3bf53aff5fa..a4d5d9511d3 100644 --- a/.github/workflows/test-wheel-linux.yml +++ b/.github/workflows/test-wheel-linux.yml @@ -296,16 +296,19 @@ jobs: - name: Set up Python ${{ matrix.PY_VER }} uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 with: - # TODO: Pin beta.2 precisely until cibuildwheel catches up (b4 broke ABI for Cython) - # this precise pin requires the explicit `freethreaded`. - # When 3.15 is officially supported we can also remove the `allow-prereleases` override. - python-version: ${{ startsWith(matrix.PY_VER, '3.15') && '3.15.0-beta.2' || matrix.PY_VER }} - freethreaded: ${{ endsWith(matrix.PY_VER, 't') }} + python-version: ${{ matrix.PY_VER }} + # TODO: remove allow-prereleases once 3.15 is officially supported allow-prereleases: ${{ startsWith(matrix.PY_VER, '3.15') }} env: # we use self-hosted runners on which setup-python behaves weirdly (Python include can't be found)... AGENT_TOOLSDIRECTORY: "/opt/hostedtoolcache" + - name: Enable Scientific Python Nightly Wheels for Python 3.15 + if: ${{ startsWith(matrix.PY_VER, '3.15') }} + run: | + echo "PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple" >> "$GITHUB_ENV" + echo "PIP_ONLY_BINARY=numpy" >> "$GITHUB_ENV" + - name: Set up mini CTK if: ${{ matrix.LOCAL_CTK == '1' }} uses: ./.github/actions/fetch_ctk @@ -314,18 +317,6 @@ jobs: host-platform: ${{ inputs.host-platform }} cuda-version: ${{ matrix.CUDA_VER }} - # TODO: remove the numpy wheel steps once 3.15 is officially supported - - name: Download numpy wheel (pre-release Python) - if: ${{ startsWith(matrix.PY_VER, '3.15') }} - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 - with: - name: numpy-python${{ env.PYTHON_VERSION_FORMATTED }}-${{ inputs.host-platform }} - path: numpy-wheel - - - name: Install numpy wheel (pre-release Python) - if: ${{ startsWith(matrix.PY_VER, '3.15') }} - run: pip install numpy-wheel/*.whl - - name: Set up latest cuda_sanitizer_api if: ${{ env.SETUP_SANITIZER == '1' }} uses: ./.github/actions/fetch_ctk diff --git a/.github/workflows/test-wheel-windows.yml b/.github/workflows/test-wheel-windows.yml index 7f98a649f73..000843b9070 100644 --- a/.github/workflows/test-wheel-windows.yml +++ b/.github/workflows/test-wheel-windows.yml @@ -276,13 +276,17 @@ jobs: - name: Set up Python ${{ matrix.PY_VER }} uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 with: - # TODO: Pin beta.2 precisely until cibuildwheel catches up (b4 broke ABI for Cython) - # this precise pin requires the explicit `freethreaded`. - # When 3.15 is officially supported we can also remove the `allow-prereleases` override. - python-version: ${{ startsWith(matrix.PY_VER, '3.15') && '3.15.0-beta.2' || matrix.PY_VER }} - freethreaded: ${{ endsWith(matrix.PY_VER, 't') }} + python-version: ${{ matrix.PY_VER }} + # TODO: remove allow-prereleases once 3.15 is officially supported allow-prereleases: ${{ startsWith(matrix.PY_VER, '3.15') }} + - name: Enable Scientific Python Nightly Wheels for Python 3.15 + if: ${{ startsWith(matrix.PY_VER, '3.15') }} + shell: bash --noprofile --norc -xeuo pipefail {0} + run: | + echo "PIP_EXTRA_INDEX_URL=https://pypi.anaconda.org/scientific-python-nightly-wheels/simple" >> "$GITHUB_ENV" + echo "PIP_ONLY_BINARY=numpy" >> "$GITHUB_ENV" + - name: Verify LongPathsEnabled run: | $val = (Get-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem' -Name 'LongPathsEnabled').LongPathsEnabled @@ -300,19 +304,6 @@ jobs: host-platform: ${{ inputs.host-platform }} cuda-version: ${{ matrix.CUDA_VER }} - # TODO: remove the numpy wheel steps once 3.15 is officially supported - - name: Download numpy wheel (pre-release Python) - if: ${{ startsWith(matrix.PY_VER, '3.15') }} - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 - with: - name: numpy-python${{ env.PYTHON_VERSION_FORMATTED }}-${{ inputs.host-platform }} - path: numpy-wheel - - - name: Install numpy wheel (pre-release Python) - if: ${{ startsWith(matrix.PY_VER, '3.15') }} - shell: bash --noprofile --norc -xeuo pipefail {0} - run: pip install numpy-wheel/*.whl - - name: Set up test repetition on nightly runs shell: bash --noprofile --norc -xeuo pipefail {0} run: echo "PYTEST_ADDOPTS=\"--count=${{ inputs.nruns }}\"" >> "$GITHUB_ENV" diff --git a/ci/test-matrix.yml b/ci/test-matrix.yml index 0adb0142ae7..563774494e9 100644 --- a/ci/test-matrix.yml +++ b/ci/test-matrix.yml @@ -128,6 +128,7 @@ windows: - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '12.9.1', LOCAL_CTK: '1', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '13.0.2', LOCAL_CTK: '0', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } - { ARCH: 'amd64', PY_VER: '3.14t', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'a100', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } + - { ARCH: 'amd64', PY_VER: '3.15', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'l4', GPU_COUNT: '1', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } # special runners - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '1', GPU: 't4', GPU_COUNT: '2', DRIVER: 'latest', DRIVER_MODE: 'TCC' } - { ARCH: 'amd64', PY_VER: '3.14', CUDA_VER: '13.3.0', LOCAL_CTK: '0', GPU: 'h100', GPU_COUNT: '2', DRIVER: 'latest', DRIVER_MODE: 'MCDM' } diff --git a/cuda_bindings/pyproject.toml b/cuda_bindings/pyproject.toml index 1f6c9393ea3..35739a4fedc 100644 --- a/cuda_bindings/pyproject.toml +++ b/cuda_bindings/pyproject.toml @@ -48,7 +48,8 @@ test = [ "setuptools>=80.0.0", # TODO: remove the Python 3.15 guard once 3.15 is officially supported "matplotlib>=3.5.0,<=3.10.9; python_version < '3.15'", - "numpy>=1.21.1,<=2.5.0", + # <=2.6.0.dev0 admits scientific-python nightlies (for Python 3.15) + "numpy>=1.21.1,<=2.6.0.dev0", "pytest==9.1.0", "pytest-benchmark==5.2.3", "pytest-repeat==0.9.4", diff --git a/cuda_core/pyproject.toml b/cuda_core/pyproject.toml index 29e6b2a4bf9..f3afa29241d 100644 --- a/cuda_core/pyproject.toml +++ b/cuda_core/pyproject.toml @@ -73,7 +73,8 @@ test = [ # TODO: remove the Python 3.15 guard once 3.15 is officially supported "cffi==2.0.0; python_version < '3.15'", ] -ml-dtypes = ["ml-dtypes>=0.5.4,<0.6.0"] +# TODO: drop the Windows 3.15 guard once ml-dtypes publishes cp315 Windows wheels +ml-dtypes = ["ml-dtypes>=0.5.4,<0.6.0; sys_platform != 'win32' or python_version < '3.15'"] test-cu12 = [ {include-group = "ml-dtypes" }, {include-group = "test" }, "cupy-cuda12x; python_version < '3.14'", "cuda-toolkit[cudart]==12.*"] # runtime headers needed by CuPy test-cu13 = [ {include-group = "ml-dtypes" }, {include-group = "test" }, "cupy-cuda13x; python_version < '3.14'", "cuda-toolkit[cudart]==13.*"] # runtime headers needed by CuPy # free threaded build, cupy doesn't support free-threaded builds yet, so avoid installing it for now From e5c7b067259439f2897435ddeeb56c60c2e9a5de Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Mon, 3 Aug 2026 22:42:32 -0400 Subject: [PATCH 21/50] Remove tests involving NVLINK_MAX_LINKS (#2483) --- cuda_bindings/tests/nvml/test_nvlink.py | 5 ----- cuda_bindings/tests/nvml/test_pynvml.py | 21 --------------------- 2 files changed, 26 deletions(-) diff --git a/cuda_bindings/tests/nvml/test_nvlink.py b/cuda_bindings/tests/nvml/test_nvlink.py index 04bc8eaae4c..1ea9e25dfa7 100644 --- a/cuda_bindings/tests/nvml/test_nvlink.py +++ b/cuda_bindings/tests/nvml/test_nvlink.py @@ -27,8 +27,3 @@ def test_nvlink_get_link_count(all_devices): assert value.nvml_return == nvml.Return.SUCCESS or value.nvml_return == nvml.Return.ERROR_NOT_SUPPORTED, ( f"Unexpected return {value.nvml_return} for link count field query" ) - - # The feature_nvlink_supported detection is not robust, so we - # can't be more specific about how many links we should find. - if value.nvml_return == nvml.Return.SUCCESS: - assert value.value.ui_val[0] <= nvml.NVLINK_MAX_LINKS, f"Unexpected link count {value.value.ui_val[0]}" diff --git a/cuda_bindings/tests/nvml/test_pynvml.py b/cuda_bindings/tests/nvml/test_pynvml.py index 2d1029e9d9b..ad8eb4c63fa 100644 --- a/cuda_bindings/tests/nvml/test_pynvml.py +++ b/cuda_bindings/tests/nvml/test_pynvml.py @@ -265,27 +265,6 @@ def test_device_get_pcie_throughput(ngpus, handles): # Test pynvml.nvmlDeviceGetNvLinkRemotePciInfo -@pytest.mark.parametrize( - "cap_type", - [ - nvml.NvLinkCapability.NVLINK_CAP_P2P_SUPPORTED, # P2P over NVLink is supported - nvml.NvLinkCapability.NVLINK_CAP_SYSMEM_ACCESS, # Access to system memory is supported - nvml.NvLinkCapability.NVLINK_CAP_P2P_ATOMICS, # P2P atomics are supported - nvml.NvLinkCapability.NVLINK_CAP_SYSMEM_ATOMICS, # System memory atomics are supported - nvml.NvLinkCapability.NVLINK_CAP_SLI_BRIDGE, # SLI is supported over this link - nvml.NvLinkCapability.NVLINK_CAP_VALID, - ], -) # Link is supported on this device -def test_device_get_nvlink_capability(ngpus, handles, cap_type): - for i in range(ngpus): - for j in range(nvml.NVLINK_MAX_LINKS): - # By the documentation, this should be supported on PASCAL or newer, - # but this also seems to fail on newer. - with unsupported_before(handles[i], None): - cap = nvml.device_get_nvlink_capability(handles[i], j, cap_type) - assert cap >= 0 - - # Test pynvml.nvmlDeviceResetNvLinkUtilizationCounter # Test pynvml.nvmlDeviceSetNvLinkUtilizationControl # Test pynvml.nvmlDeviceGetNvLinkUtilizationCounter From fcde4b1e7963830d66bce2e16e8f79d1cbcbc3ad Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Tue, 4 Aug 2026 10:04:48 -0700 Subject: [PATCH 22/50] Make temperature threshold checks forward-compatible (#2488) Compare raw NVML device architecture values so architectures newer than the generated DeviceArch enum do not raise ValueError before the threshold query. Add regression coverage for an unrecognized architecture value. --- cuda_core/cuda/core/system/_temperature.pxi | 4 +++- cuda_core/tests/system/test_system_device.py | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/cuda_core/cuda/core/system/_temperature.pxi b/cuda_core/cuda/core/system/_temperature.pxi index f5eed73de2c..82dc0cab785 100644 --- a/cuda_core/cuda/core/system/_temperature.pxi +++ b/cuda_core/cuda/core/system/_temperature.pxi @@ -173,7 +173,9 @@ cdef class Temperature: nvml.TemperatureThresholds.TEMPERATURE_THRESHOLD_MEM_MAX, nvml.TemperatureThresholds.TEMPERATURE_THRESHOLD_GPU_MAX ): - device_arch = nvml.DeviceArch(nvml.device_get_architecture(self._handle)) + # Compare the raw value so newer NVML architecture constants remain + # forward-compatible. + device_arch = nvml.device_get_architecture(self._handle) if device_arch >= nvml.DeviceArch.ADA: warnings.warn( f"{threshold_type} is no longer recommended for Ada and later architectures. " diff --git a/cuda_core/tests/system/test_system_device.py b/cuda_core/tests/system/test_system_device.py index b8fe3505674..a4722d05cbb 100644 --- a/cuda_core/tests/system/test_system_device.py +++ b/cuda_core/tests/system/test_system_device.py @@ -722,6 +722,25 @@ def test_temperature(): assert sensor.default_min_temp <= sensor.current_temp <= sensor.default_max_temp +@pytest.mark.thread_unsafe(reason="Temporarily replaces process-global NVML functions") +@pytest.mark.agent_authored(model="gpt-5.6-sol") +def test_temperature_threshold_unrecognized_device_arch(monkeypatch): + temperature = system.Device(index=0).temperature + unrecognized_arch = int(nvml.DeviceArch.UNKNOWN) - 1 + with pytest.raises(ValueError): + nvml.DeviceArch(unrecognized_arch) + + monkeypatch.setattr(nvml, "device_get_architecture", lambda _handle: unrecognized_arch) + monkeypatch.setattr( + nvml, + "device_get_temperature_threshold", + lambda _handle, _threshold: 42, + ) + + with pytest.warns(DeprecationWarning, match="no longer recommended"): + assert temperature.get_threshold(typing.TemperatureThresholds.SHUTDOWN) == 42 + + @pytest.mark.agent_authored(model="claude-opus-4.8") def test_temperature_arg_validation(): # Both getters reject an unknown key before issuing any NVML call. From d9da4422170b6673a407983b4df302ae4d8207b8 Mon Sep 17 00:00:00 2001 From: Omar Atie Date: Tue, 4 Aug 2026 10:26:38 -0700 Subject: [PATCH 23/50] fix(cuda.core): fall back to driver when nvJitLink < 12.3 is installed (#2409) * fix(cuda.core): fall back to driver when nvJitLink < 12.3 is installed Stop probing nvJitLink availability via module.version(), which calls the unversioned nvJitLinkVersion symbol missing in nvJitLink 12.0-12.2. Use symbol pointer inspection via _nvjitlink_has_version_symbol() instead, restoring cuda-core 0.6.0 fallback behavior. Fixes #2408 Signed-off-by: Omar Atie Co-authored-by: Cursor * test(cuda.core): add coverage for nvJitLink <12.3 driver fallback Add regression tests for Linker.which_backend() and _decide_nvjitlink_or_driver() when the nvJitLinkVersion symbol is missing (nvJitLink 12.0-12.2). Related to #2408 Signed-off-by: Omar Atie Co-authored-by: Cursor * docs(cuda.core): add 1.2.0 release note for nvJitLink <12.3 fallback fix Document the #2408 regression fix in the cuda.core 1.2.0 release notes. Related to #2408 Signed-off-by: Omar Atie Co-authored-by: Cursor * fix(cuda.core): probe nvJitLink version under DynamicLibNotFoundError guard Address review feedback: keep the >=12.3 version-symbol check inside _optional_cuda_import's probe so a missing nvJitLink dylib still falls back to cuLink. Continue avoiding module.version(), which raises FunctionNotFoundError on nvJitLink 12.0-12.2 (#2408). Add coverage for missing-dylib fallback and a guard that the probe does not call module.version(). Signed-off-by: Omar Atie Co-authored-by: Cursor * fix(cuda.core): use explicit try/except for nvJitLink version probe Address review feedback: drop the probe side-effect and catch DynamicLibNotFoundError around _nvjitlink_has_version_symbol so missing dylibs still fall back to cuLink. Keep avoiding module.version() for nvJitLink <12.3 (#2408). Mark newly added tests with agent_authored authorship markers. Signed-off-by: Omar Atie Co-authored-by: Cursor * fix(cuda.core): drop obsolete nvJitLink probe comments Signed-off-by: Omar Atie Co-authored-by: Cursor --------- Signed-off-by: Omar Atie Co-authored-by: Omar Atie Co-authored-by: Cursor Co-authored-by: Michael Wang <13521008+isVoid@users.noreply.github.com> --- cuda_core/cuda/core/_linker.pyx | 27 +++--- cuda_core/docs/source/release/1.2.0-notes.rst | 9 ++ cuda_core/tests/test_linker.py | 43 +++++++++ .../tests/test_optional_dependency_imports.py | 87 ++++++++++++++++++- 4 files changed, 153 insertions(+), 13 deletions(-) diff --git a/cuda_core/cuda/core/_linker.pyx b/cuda_core/cuda/core/_linker.pyx index 2f4d8efd3a7..0687632c3bb 100644 --- a/cuda_core/cuda/core/_linker.pyx +++ b/cuda_core/cuda/core/_linker.pyx @@ -29,6 +29,7 @@ from dataclasses import dataclass from typing import TYPE_CHECKING, Union from warnings import warn +from cuda.pathfinder import DynamicLibNotFoundError from cuda.pathfinder._optional_cuda_import import _optional_cuda_import from cuda.core._device import Device from cuda.core._module import ObjectCode @@ -683,22 +684,26 @@ def _decide_nvjitlink_or_driver() -> bool: " For best results, consider upgrading to a recent version of" ) - nvjitlink_module = _optional_cuda_import( - "cuda.bindings.nvjitlink", - probe_function=lambda module: module.version(), # probe triggers nvJitLink runtime load - ) + nvjitlink_module = _optional_cuda_import("cuda.bindings.nvjitlink") if nvjitlink_module is None: warn_txt = f"cuda.bindings.nvjitlink is not available, therefore {warn_txt_common} cuda-bindings." else: from cuda.bindings._internal import nvjitlink - if _nvjitlink_has_version_symbol(nvjitlink): - _use_nvjitlink_backend = True - return False # Use nvjitlink - warn_txt = ( - f"{'nvJitLink*.dll' if sys.platform == 'win32' else 'libnvJitLink.so*'} is too old (<12.3)." - f" Therefore cuda.bindings.nvjitlink is not usable and {warn_txt_common} nvJitLink." - ) + try: + has_version_symbol = _nvjitlink_has_version_symbol(nvjitlink) + except DynamicLibNotFoundError: + warn_txt = ( + f"cuda.bindings.nvjitlink is not available, therefore {warn_txt_common} cuda-bindings." + ) + else: + if has_version_symbol: + _use_nvjitlink_backend = True + return False # Use nvjitlink + warn_txt = ( + f"{'nvJitLink*.dll' if sys.platform == 'win32' else 'libnvJitLink.so*'} is too old (<12.3)." + f" Therefore cuda.bindings.nvjitlink is not usable and {warn_txt_common} nvJitLink." + ) warn(warn_txt, stacklevel=2, category=RuntimeWarning) _driver = driver diff --git a/cuda_core/docs/source/release/1.2.0-notes.rst b/cuda_core/docs/source/release/1.2.0-notes.rst index de255d01cbb..cf884ed64cc 100644 --- a/cuda_core/docs/source/release/1.2.0-notes.rst +++ b/cuda_core/docs/source/release/1.2.0-notes.rst @@ -25,6 +25,15 @@ Fixes and enhancements versions 12.2 or newer. (`#2352 `__) +- :meth:`Linker.which_backend` and constructing a :class:`Linker` no longer + raise ``FunctionNotFoundError`` when an nvJitLink older than 12.3 + (12.0–12.2) is installed. These versions do not export the unversioned + ``nvJitLinkVersion`` symbol, so probing the version crashed instead of + falling back. ``cuda.core`` now warns and falls back to the driver + (``cuLink``) backend, restoring the pre-0.7.0 behavior. + (`#2409 `__, + closes `#2408 `__) + Deprecation Notices ------------------- diff --git a/cuda_core/tests/test_linker.py b/cuda_core/tests/test_linker.py index 9d95b5fd9c3..4f4433a1a1a 100644 --- a/cuda_core/tests/test_linker.py +++ b/cuda_core/tests/test_linker.py @@ -303,6 +303,49 @@ def fake_decide(): assert result == "nvJitLink" assert called, "_decide_nvjitlink_or_driver was not called" + @pytest.mark.agent_authored(model="grok-4.5") + def test_which_backend_falls_back_when_nvjitlink_too_old(self, monkeypatch): + """Regression test for #2408: old nvJitLink must not crash which_backend().""" + monkeypatch.setattr(_linker, "_use_nvjitlink_backend", None) + monkeypatch.setattr(_linker, "_driver", None) + + def fake__optional_cuda_import(modname, probe_function=None): + assert modname == "cuda.bindings.nvjitlink" + assert probe_function is None + return object() + + monkeypatch.setattr(_linker, "_optional_cuda_import", fake__optional_cuda_import) + monkeypatch.setattr(_linker, "_nvjitlink_has_version_symbol", lambda _nvjitlink: False) + + with pytest.warns(RuntimeWarning, match="too old \\(<12.3\\)"): + assert Linker.which_backend() == "driver" + + assert _linker._use_nvjitlink_backend is False + + @pytest.mark.agent_authored(model="grok-4.5") + def test_which_backend_falls_back_when_dylib_missing(self, monkeypatch): + """Missing nvJitLink dylib must fall back without raising.""" + from cuda.pathfinder import DynamicLibNotFoundError + + monkeypatch.setattr(_linker, "_use_nvjitlink_backend", None) + monkeypatch.setattr(_linker, "_driver", None) + + def raise_missing(_nvjitlink): + raise DynamicLibNotFoundError("missing") + + def fake__optional_cuda_import(modname, probe_function=None): + assert modname == "cuda.bindings.nvjitlink" + assert probe_function is None + return object() + + monkeypatch.setattr(_linker, "_nvjitlink_has_version_symbol", raise_missing) + monkeypatch.setattr(_linker, "_optional_cuda_import", fake__optional_cuda_import) + + with pytest.warns(RuntimeWarning, match="cuda.bindings.nvjitlink is not available"): + assert Linker.which_backend() == "driver" + + assert _linker._use_nvjitlink_backend is False + def test_which_backend_is_classmethod(self): attr = inspect.getattr_static(Linker, "which_backend") assert isinstance(attr, classmethod) diff --git a/cuda_core/tests/test_optional_dependency_imports.py b/cuda_core/tests/test_optional_dependency_imports.py index 02edcc9839a..9ba7358f9fe 100644 --- a/cuda_core/tests/test_optional_dependency_imports.py +++ b/cuda_core/tests/test_optional_dependency_imports.py @@ -5,6 +5,7 @@ import pytest from cuda.core import _linker, _program +from cuda.pathfinder import DynamicLibNotFoundError @pytest.fixture(autouse=True) @@ -78,7 +79,7 @@ def fake__optional_cuda_import(modname, probe_function=None): def test_decide_nvjitlink_or_driver_reraises_nested_module_not_found(monkeypatch): def fake__optional_cuda_import(modname, probe_function=None): assert modname == "cuda.bindings.nvjitlink" - assert probe_function is not None + assert probe_function is None err = ModuleNotFoundError("No module named 'not_a_real_dependency'") err.name = "not_a_real_dependency" raise err @@ -93,7 +94,7 @@ def fake__optional_cuda_import(modname, probe_function=None): def test_decide_nvjitlink_or_driver_falls_back_when_module_missing(monkeypatch): def fake__optional_cuda_import(modname, probe_function=None): assert modname == "cuda.bindings.nvjitlink" - assert probe_function is not None + assert probe_function is None return None monkeypatch.setattr(_linker, "_optional_cuda_import", fake__optional_cuda_import) @@ -103,3 +104,85 @@ def fake__optional_cuda_import(modname, probe_function=None): assert use_driver_backend is True assert _linker._use_nvjitlink_backend is False + + +@pytest.mark.agent_authored(model="grok-4.5") +def test_decide_nvjitlink_or_driver_falls_back_when_dylib_missing(monkeypatch): + """Missing nvJitLink dylib must fall back via DynamicLibNotFoundError.""" + + def raise_missing(_nvjitlink): + raise DynamicLibNotFoundError("libnvJitLink missing") + + def fake__optional_cuda_import(modname, probe_function=None): + assert modname == "cuda.bindings.nvjitlink" + assert probe_function is None + return object() + + monkeypatch.setattr(_linker, "_optional_cuda_import", fake__optional_cuda_import) + monkeypatch.setattr(_linker, "_nvjitlink_has_version_symbol", raise_missing) + + with pytest.warns(RuntimeWarning, match="cuda.bindings.nvjitlink is not available"): + use_driver_backend = _linker._decide_nvjitlink_or_driver() + + assert use_driver_backend is True + assert _linker._use_nvjitlink_backend is False + + +@pytest.mark.agent_authored(model="grok-4.5") +def test_decide_nvjitlink_or_driver_falls_back_when_nvjitlink_too_old(monkeypatch): + def fake__optional_cuda_import(modname, probe_function=None): + assert modname == "cuda.bindings.nvjitlink" + assert probe_function is None + return object() + + monkeypatch.setattr(_linker, "_optional_cuda_import", fake__optional_cuda_import) + monkeypatch.setattr(_linker, "_nvjitlink_has_version_symbol", lambda _nvjitlink: False) + + with pytest.warns(RuntimeWarning, match="too old \\(<12.3\\)"): + use_driver_backend = _linker._decide_nvjitlink_or_driver() + + assert use_driver_backend is True + assert _linker._use_nvjitlink_backend is False + + +@pytest.mark.agent_authored(model="grok-4.5") +def test_decide_nvjitlink_or_driver_selects_nvjitlink_when_version_symbol_present(monkeypatch): + def fake__optional_cuda_import(modname, probe_function=None): + assert modname == "cuda.bindings.nvjitlink" + assert probe_function is None + return object() + + monkeypatch.setattr(_linker, "_optional_cuda_import", fake__optional_cuda_import) + monkeypatch.setattr(_linker, "_nvjitlink_has_version_symbol", lambda _nvjitlink: True) + + use_driver_backend = _linker._decide_nvjitlink_or_driver() + + assert use_driver_backend is False + assert _linker._use_nvjitlink_backend is True + + +@pytest.mark.agent_authored(model="grok-4.5") +def test_decide_nvjitlink_or_driver_does_not_call_version(monkeypatch): + """Regression guard for #2408: must not call module.version().""" + called = {"version": False, "inspect": False} + + class FakeModule: + def version(self): + called["version"] = True + raise AssertionError("module.version() must not be used for nvJitLink probing") + + def fake_has_version(_nvjitlink): + called["inspect"] = True + return True + + def fake__optional_cuda_import(modname, probe_function=None): + assert modname == "cuda.bindings.nvjitlink" + assert probe_function is None + return FakeModule() + + monkeypatch.setattr(_linker, "_optional_cuda_import", fake__optional_cuda_import) + monkeypatch.setattr(_linker, "_nvjitlink_has_version_symbol", fake_has_version) + + assert _linker._decide_nvjitlink_or_driver() is False + assert called["inspect"] is True + assert called["version"] is False From 19e66499c207b6f3c88c868b7af3f430983b32e8 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Tue, 4 Aug 2026 14:19:52 -0400 Subject: [PATCH 24/50] Fix #2377: Reorganize the test helpers (where appropriate) to cuda_python_test_helpers (#2384) * Experiment: Install test_helpers as a package * Try something different in CI * Reorganize all the tests * Update a few more imports --- .github/workflows/coverage.yml | 1 - .../cuda/bindings/_test_helpers/__init__.py | 6 - .../cuda/bindings/_test_helpers/arch_check.py | 70 ----------- cuda_bindings/pixi.toml | 3 + cuda_bindings/tests/conftest.py | 28 +++-- cuda_bindings/tests/nvml/__init__.py | 3 +- cuda_bindings/tests/nvml/conftest.py | 2 +- cuda_bindings/tests/nvml/test_pynvml.py | 6 +- cuda_bindings/tests/nvml/util.py | 21 ---- cuda_bindings/tests/test_cuda.py | 2 +- cuda_bindings/tests/test_cudart.py | 2 +- cuda_bindings/tests/test_examples.py | 3 +- cuda_bindings/tests/test_interoperability.py | 2 +- cuda_core/pixi.toml | 3 + cuda_core/tests/conftest.py | 113 ++++-------------- .../example_tests/test_basic_examples.py | 8 +- cuda_core/tests/graph/test_device_launch.py | 2 +- cuda_core/tests/graph/test_graph_builder.py | 2 +- .../graph/test_graph_builder_conditional.py | 2 +- .../tests/graph/test_graph_definition.py | 2 +- .../graph/test_graph_definition_errors.py | 2 +- .../test_graph_definition_integration.py | 2 +- .../graph/test_graph_definition_lifetime.py | 2 +- .../graph/test_graph_definition_mutation.py | 2 +- .../tests/graph/test_graph_memory_resource.py | 4 +- cuda_core/tests/graph/test_graph_update.py | 2 +- cuda_core/tests/memory/test_managed_ops.py | 2 +- cuda_core/tests/system/conftest.py | 28 ----- cuda_core/tests/system/test_nvml_context.py | 4 +- cuda_core/tests/system/test_system_device.py | 2 +- cuda_core/tests/system/test_system_events.py | 2 +- cuda_core/tests/system/test_system_system.py | 3 +- cuda_core/tests/test_device.py | 2 +- cuda_core/tests/test_launcher.py | 4 +- .../tests/test_managed_memory_warning.py | 2 +- cuda_core/tests/test_memory.py | 7 +- cuda_core/tests/test_object_protocols.py | 2 +- cuda_core/tests/test_tensor_map.py | 2 +- cuda_core/tests/test_utils.py | 2 +- .../tests/test_driver_lib_loading.py | 2 +- .../tests/test_find_nvidia_headers.py | 2 +- .../tests/test_load_nvidia_dynamic_lib.py | 2 +- .../cuda_python_test_helpers/__init__.py | 4 +- .../_pytest_plugin.py | 25 ++-- .../cuda_python_test_helpers/arch_check.py | 93 ++++++++++++++ .../cuda_python_test_helpers}/marks.py | 25 +++- .../cuda_python_test_helpers}/mempool.py | 9 +- .../cuda_python_test_helpers}/pep723.py | 0 48 files changed, 217 insertions(+), 302 deletions(-) delete mode 100644 cuda_bindings/cuda/bindings/_test_helpers/__init__.py delete mode 100644 cuda_bindings/cuda/bindings/_test_helpers/arch_check.py delete mode 100644 cuda_core/tests/system/conftest.py rename conftest.py => cuda_python_test_helpers/cuda_python_test_helpers/_pytest_plugin.py (72%) create mode 100644 cuda_python_test_helpers/cuda_python_test_helpers/arch_check.py rename {cuda_core/tests/helpers => cuda_python_test_helpers/cuda_python_test_helpers}/marks.py (66%) rename {cuda_bindings/cuda/bindings/_test_helpers => cuda_python_test_helpers/cuda_python_test_helpers}/mempool.py (84%) rename {cuda_bindings/cuda/bindings/_test_helpers => cuda_python_test_helpers/cuda_python_test_helpers}/pep723.py (100%) diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index f1b8eb9f3a2..e354a204d02 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -335,7 +335,6 @@ jobs: - name: Install test dependencies and coverage tools run: | - .venv/Scripts/pip install -v ./cuda_python_test_helpers .venv/Scripts/pip install coverage pytest-cov Cython .venv/Scripts/pip install --group ./cuda_pathfinder/pyproject.toml:test .venv/Scripts/pip install --group ./cuda_bindings/pyproject.toml:test diff --git a/cuda_bindings/cuda/bindings/_test_helpers/__init__.py b/cuda_bindings/cuda/bindings/_test_helpers/__init__.py deleted file mode 100644 index 2cfab242d2a..00000000000 --- a/cuda_bindings/cuda/bindings/_test_helpers/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - - -# This package contains test helper utilities that may also be useful for other libraries outside of `cuda.bindings`, -# such as `cuda.core`. These utilities are not part of the public API of `cuda.bindings` and may change without notice. diff --git a/cuda_bindings/cuda/bindings/_test_helpers/arch_check.py b/cuda_bindings/cuda/bindings/_test_helpers/arch_check.py deleted file mode 100644 index 3ab48be6e02..00000000000 --- a/cuda_bindings/cuda/bindings/_test_helpers/arch_check.py +++ /dev/null @@ -1,70 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - - -from contextlib import contextmanager -from functools import cache - -import pytest - -from cuda.bindings import nvml -from cuda.bindings._internal.utils import FunctionNotFoundError as NvmlSymbolNotFoundError - - -@cache -def hardware_supports_nvml(): - """ - Tries to call the simplest NVML API possible to see if just the basics - works. If not we are probably on one of the platforms where NVML is not - supported at all (e.g. Jetson Orin). - """ - nvml.init_v2() - try: - nvml.system_get_driver_branch() - except (nvml.NotSupportedError, nvml.UnknownError): - return False - else: - return True - finally: - nvml.shutdown() - - -@contextmanager -def unsupported_before(device: int, expected_device_arch: nvml.DeviceArch | str | None): - device_arch = nvml.device_get_architecture(device) - - if isinstance(expected_device_arch, nvml.DeviceArch): - expected_device_arch_int = int(expected_device_arch) - elif expected_device_arch == "FERMI": - expected_device_arch_int = 1 - else: - expected_device_arch_int = 0 - - if expected_device_arch is None or expected_device_arch == "HAS_INFOROM" or device_arch == nvml.DeviceArch.UNKNOWN: - # In this case, we don't /know/ if it will fail, but we are ok if it - # does or does not. - - # TODO: There are APIs that are documented as supported only if the - # device has an InfoROM, but I couldn't find a way to detect that. For - # now, they are just handled as "possibly failing". - - try: - yield - except (nvml.NotSupportedError, nvml.FunctionNotFoundError, NvmlSymbolNotFoundError): - # The API call raised NotSupportedError, NVML status FunctionNotFoundError, - # or NvmlSymbolNotFoundError (symbol absent from the loaded NVML DLL), so we - # skip the test but don't fail it - pytest.skip( - f"Unsupported call for device architecture {nvml.DeviceArch(device_arch).name} " - f"on device '{nvml.device_get_name(device)}'" - ) - # If the API call worked, just continue - elif int(device_arch) < expected_device_arch_int: - # In this case, we /know/ if will fail, and we want to assert that it does. - with pytest.raises(nvml.NotSupportedError): - yield - # The above call was unsupported, so the rest of the test is skipped - pytest.skip(f"Unsupported before {expected_device_arch.name}, got {nvml.device_get_name(device)}") - else: - # In this case, we /know/ it should work, and if it fails, the test should fail. - yield diff --git a/cuda_bindings/pixi.toml b/cuda_bindings/pixi.toml index 2b566d12b1a..7c228cbdf99 100644 --- a/cuda_bindings/pixi.toml +++ b/cuda_bindings/pixi.toml @@ -15,6 +15,9 @@ cuda-version = ["12.*", "13.3.*"] [feature.test.dependencies] cuda-bindings = { path = "." } pytest = ">=6.2.4" + +[feature.test.pypi-dependencies] +cuda-python-test-helpers = { path = "../cuda_python_test_helpers", editable = true } pytest-benchmark = ">=3.4.1" pytest-randomly = "*" pytest-repeat = "*" diff --git a/cuda_bindings/tests/conftest.py b/cuda_bindings/tests/conftest.py index 1618d63a133..fada7d95601 100644 --- a/cuda_bindings/tests/conftest.py +++ b/cuda_bindings/tests/conftest.py @@ -2,30 +2,32 @@ # SPDX-License-Identifier: Apache-2.0 import functools +import importlib import inspect import pathlib import sys from contextlib import contextmanager -from importlib.metadata import PackageNotFoundError, distribution import pytest import cuda.bindings.driver as cuda -# Import shared test helpers for tests across subprojects. -# PLEASE KEEP IN SYNC with copies in other conftest.py in this repo. -_test_helpers_root = pathlib.Path(__file__).resolve().parents[2] / "cuda_python_test_helpers" +# Keep in sync with cuda_core/tests/conftest.py. try: - distribution("cuda-python-test-helpers") -except PackageNotFoundError as exc: + import cuda_python_test_helpers._pytest_plugin # noqa: F401 +except ImportError as e: + # Don't call .resolve(): resolving symlinks can make parents[2] point + # somewhere other than the monorepo root if a sub-directory is symlinked. + _test_helpers_root = pathlib.Path(__file__).parents[2] / "cuda_python_test_helpers" if not _test_helpers_root.is_dir(): - raise RuntimeError( - f"cuda-python-test-helpers not installed; expected checkout path {_test_helpers_root}" - ) from exc - - test_helpers_root = str(_test_helpers_root) - if test_helpers_root not in sys.path: - sys.path.insert(0, test_helpers_root) + raise RuntimeError(f"cuda-python-test-helpers not installed and not found at {_test_helpers_root}") from e + for _k in list(sys.modules): + if _k == "cuda_python_test_helpers" or _k.startswith("cuda_python_test_helpers."): + del sys.modules[_k] + sys.path.insert(0, str(_test_helpers_root)) + importlib.invalidate_caches() + +pytest_plugins = ["cuda_python_test_helpers._pytest_plugin"] def pytest_configure(config): diff --git a/cuda_bindings/tests/nvml/__init__.py b/cuda_bindings/tests/nvml/__init__.py index c746f897d2d..4baf1b49bc0 100644 --- a/cuda_bindings/tests/nvml/__init__.py +++ b/cuda_bindings/tests/nvml/__init__.py @@ -3,8 +3,7 @@ import pytest - -from cuda.bindings._test_helpers.arch_check import hardware_supports_nvml +from cuda_python_test_helpers.arch_check import hardware_supports_nvml if not hardware_supports_nvml(): pytest.skip("NVML not supported on this platform", allow_module_level=True) diff --git a/cuda_bindings/tests/nvml/conftest.py b/cuda_bindings/tests/nvml/conftest.py index 9897420e38d..7fb1aed4be4 100644 --- a/cuda_bindings/tests/nvml/conftest.py +++ b/cuda_bindings/tests/nvml/conftest.py @@ -4,9 +4,9 @@ from collections import namedtuple import pytest +from cuda_python_test_helpers.arch_check import unsupported_before # noqa: F401 from cuda.bindings import nvml -from cuda.bindings._test_helpers.arch_check import unsupported_before # noqa: F401 class NVMLInitializer: diff --git a/cuda_bindings/tests/nvml/test_pynvml.py b/cuda_bindings/tests/nvml/test_pynvml.py index ad8eb4c63fa..c3a236edb12 100644 --- a/cuda_bindings/tests/nvml/test_pynvml.py +++ b/cuda_bindings/tests/nvml/test_pynvml.py @@ -9,8 +9,8 @@ import pytest from cuda.bindings import nvml +from cuda_python_test_helpers import IS_WINDOWS, IS_WSL -from . import util from .conftest import unsupported_before XFAIL_LEGACY_NVLINK_MSG = "Legacy NVLink test expected to fail." @@ -64,7 +64,7 @@ def test_device_get_handle_by_pci_bus_id(ngpus, pci_info): @pytest.mark.parametrize("scope", [nvml.AffinityScope.NODE, nvml.AffinityScope.SOCKET]) -@pytest.mark.skipif(util.is_wsl() or util.is_windows(), reason="Not supported on WSL or Windows") +@pytest.mark.skipif(IS_WSL or IS_WINDOWS, reason="Not supported on WSL or Windows") def test_device_get_memory_affinity(handles, scope): size = 1024 for handle in handles: @@ -75,7 +75,7 @@ def test_device_get_memory_affinity(handles, scope): @pytest.mark.parametrize("scope", [nvml.AffinityScope.NODE, nvml.AffinityScope.SOCKET]) -@pytest.mark.skipif(util.is_wsl() or util.is_windows(), reason="Not supported on WSL or Windows") +@pytest.mark.skipif(IS_WSL or IS_WINDOWS, reason="Not supported on WSL or Windows") def test_device_get_cpu_affinity_within_scope(handles, scope): size = 1024 for handle in handles: diff --git a/cuda_bindings/tests/nvml/util.py b/cuda_bindings/tests/nvml/util.py index 038fe58d8be..129ded8f83c 100644 --- a/cuda_bindings/tests/nvml/util.py +++ b/cuda_bindings/tests/nvml/util.py @@ -2,29 +2,8 @@ # SPDX-License-Identifier: Apache-2.0 -import functools -import platform -from pathlib import Path - from cuda.bindings import nvml -current_os = platform.system() -if current_os == "VMkernel": - current_os = "Linux" # Treat VMkernel as Linux - - -def is_windows(os=current_os): - return os == "Windows" - - -def is_linux(os=current_os): - return os == "Linux" - - -@functools.cache -def is_wsl(os=current_os): - return os == "Linux" and "microsoft" in Path("/proc/version").read_text().lower() - def is_vgpu(device): """ diff --git a/cuda_bindings/tests/test_cuda.py b/cuda_bindings/tests/test_cuda.py index 619a3dae634..e2751df9237 100644 --- a/cuda_bindings/tests/test_cuda.py +++ b/cuda_bindings/tests/test_cuda.py @@ -10,11 +10,11 @@ import numpy as np import pytest +from cuda_python_test_helpers.mempool import xfail_if_mempool_oom import cuda.bindings.driver as cuda import cuda.bindings.runtime as cudart from cuda.bindings import driver -from cuda.bindings._test_helpers.mempool import xfail_if_mempool_oom def driverVersionLessThan(target): diff --git a/cuda_bindings/tests/test_cudart.py b/cuda_bindings/tests/test_cudart.py index 5ae3369b0fd..0a4e2b8bb82 100644 --- a/cuda_bindings/tests/test_cudart.py +++ b/cuda_bindings/tests/test_cudart.py @@ -6,12 +6,12 @@ import numpy as np import pytest +from cuda_python_test_helpers.mempool import xfail_if_mempool_oom import cuda.bindings.driver as cuda import cuda.bindings.runtime as cudart from cuda import pathfinder from cuda.bindings import runtime -from cuda.bindings._test_helpers.mempool import xfail_if_mempool_oom def isSuccess(err): diff --git a/cuda_bindings/tests/test_examples.py b/cuda_bindings/tests/test_examples.py index 63a56c78fb7..652515830f8 100644 --- a/cuda_bindings/tests/test_examples.py +++ b/cuda_bindings/tests/test_examples.py @@ -7,8 +7,7 @@ import sys import pytest - -from cuda.bindings._test_helpers.pep723 import has_package_requirements_or_skip +from cuda_python_test_helpers.pep723 import has_package_requirements_or_skip examples_path = os.path.join(os.path.dirname(__file__), "..", "examples") examples_files = glob.glob(os.path.join(examples_path, "**/*.py"), recursive=True) diff --git a/cuda_bindings/tests/test_interoperability.py b/cuda_bindings/tests/test_interoperability.py index 18a37ec6b4e..08bac311a2d 100644 --- a/cuda_bindings/tests/test_interoperability.py +++ b/cuda_bindings/tests/test_interoperability.py @@ -3,10 +3,10 @@ import numpy as np import pytest +from cuda_python_test_helpers.mempool import xfail_if_mempool_oom import cuda.bindings.driver as cuda import cuda.bindings.runtime as cudart -from cuda.bindings._test_helpers.mempool import xfail_if_mempool_oom def supportsMemoryPool(): diff --git a/cuda_core/pixi.toml b/cuda_core/pixi.toml index 3fcdfdffe88..928ea718ff2 100644 --- a/cuda_core/pixi.toml +++ b/cuda_core/pixi.toml @@ -16,6 +16,9 @@ cuda-version = ["12.*", "13.3.*"] cuda-core = { path = "." } ml_dtypes = "*" pytest = "*" + +[feature.test.pypi-dependencies] +cuda-python-test-helpers = { path = "../cuda_python_test_helpers", editable = true } pytest-benchmark = "*" pytest-randomly = "*" pytest-repeat = "*" diff --git a/cuda_core/tests/conftest.py b/cuda_core/tests/conftest.py index 8e4bfb7ff4b..34498df83fc 100644 --- a/cuda_core/tests/conftest.py +++ b/cuda_core/tests/conftest.py @@ -2,15 +2,35 @@ # SPDX-License-Identifier: Apache-2.0 import functools +import importlib import multiprocessing import os import pathlib import sys from contextlib import contextmanager -from importlib.metadata import PackageNotFoundError, distribution import pytest +# Keep in sync with cuda_bindings/tests/conftest.py. +try: + import cuda_python_test_helpers._pytest_plugin # noqa: F401 +except ImportError as e: + # Don't call .resolve(): resolving symlinks can make parents[2] point + # somewhere other than the monorepo root if a sub-directory is symlinked. + _test_helpers_root = pathlib.Path(__file__).parents[2] / "cuda_python_test_helpers" + if not _test_helpers_root.is_dir(): + raise RuntimeError(f"cuda-python-test-helpers not installed and not found at {_test_helpers_root}") from e + for _k in list(sys.modules): + if _k == "cuda_python_test_helpers" or _k.startswith("cuda_python_test_helpers."): + del sys.modules[_k] + sys.path.insert(0, str(_test_helpers_root)) + importlib.invalidate_caches() + +pytest_plugins = ["cuda_python_test_helpers._pytest_plugin"] + +from cuda_python_test_helpers.marks import skipif_need_cuda_headers # noqa: F401 (re-exported for tests) +from cuda_python_test_helpers.mempool import xfail_if_mempool_oom + import cuda.core from cuda.bindings import driver from cuda.core import ( @@ -24,72 +44,6 @@ _device, ) from cuda.core._utils.cuda_utils import CUDAError, handle_return -from cuda.pathfinder import get_cuda_path_or_home - -try: - from cuda.bindings._test_helpers.mempool import xfail_if_mempool_oom -except ModuleNotFoundError: - # Older cuda.bindings artifacts (for example 12.9.x backports) do not ship - # this helper yet. Keep the fallback local so tests against published - # bindings still xfail the known Windows MCDM mempool setup issue. - # - # Keep in sync with cuda_bindings/cuda/bindings/_test_helpers/mempool.py. - # This copy is intentionally simpler because it only handles cuda_core - # CUDAError exceptions when the shared helper is absent. - def _is_windows_mcdm_device(device=0): - if sys.platform != "win32": - return False - import cuda.bindings.nvml as nvml - - device_id = int(getattr(device, "device_id", device)) - (err,) = driver.cuInit(0) - if err != driver.CUresult.CUDA_SUCCESS: - return False - err, pci_bus_id = driver.cuDeviceGetPCIBusId(13, device_id) - if err != driver.CUresult.CUDA_SUCCESS: - return False - pci_bus_id = pci_bus_id.split(b"\x00", 1)[0].decode("ascii") - nvml.init_v2() - try: - handle = nvml.device_get_handle_by_pci_bus_id_v2(pci_bus_id) - current, _ = nvml.device_get_driver_model_v2(handle) - return current == nvml.DriverModel.DRIVER_MCDM - finally: - nvml.shutdown() - - def xfail_if_mempool_oom(err_or_exc, api_name=None, device=0): - if api_name is not None and not isinstance(api_name, str): - device = api_name - api_name = None - - if "CUDA_ERROR_OUT_OF_MEMORY" not in str(err_or_exc): - return - try: - is_windows_mcdm = _is_windows_mcdm_device(device) - except Exception: - # If MCDM detection fails, leave the primary test failure visible. - return - if not is_windows_mcdm: - return - - api_context = f"{api_name} " if api_name else "" - pytest.xfail(f"{api_context}could not reserve VA for mempool operations on Windows MCDM") - - -# Import shared test helpers for tests across subprojects. -# PLEASE KEEP IN SYNC with copies in other conftest.py in this repo. -_test_helpers_root = pathlib.Path(__file__).resolve().parents[2] / "cuda_python_test_helpers" -try: - distribution("cuda-python-test-helpers") -except PackageNotFoundError as exc: - if not _test_helpers_root.is_dir(): - raise RuntimeError( - f"cuda-python-test-helpers not installed; expected checkout path {_test_helpers_root}" - ) from exc - - test_helpers_root = str(_test_helpers_root) - if test_helpers_root not in sys.path: - sys.path.insert(0, test_helpers_root) def pytest_configure(config): @@ -252,7 +206,9 @@ def _device_id_from_resource_options(device, args, kwargs): def _require_ipc_mempool_devices(devices): """Return devices if they all support IPC-enabled mempools, otherwise skip.""" - from helpers import IS_WSL, supports_ipc_mempool + from helpers import supports_ipc_mempool + + from cuda_python_test_helpers import IS_WSL checked_devices = tuple(devices) @@ -445,24 +401,3 @@ def test_something(memory_resource_factory): mr = MRClass() """ return request.param - - -# Please keep in sync with the copy in the top-level conftest.py. -def _cuda_headers_available() -> bool: - """Return True if CUDA headers are available, False if no CUDA path is set. - - Raises AssertionError if a CUDA path is set but has no include/ subdirectory. - """ - cuda_path = get_cuda_path_or_home() - if cuda_path is None: - return False - assert os.path.isdir(os.path.join(cuda_path, "include")), ( - f"CUDA path {cuda_path} does not contain an 'include' subdirectory" - ) - return True - - -skipif_need_cuda_headers = pytest.mark.skipif( - not _cuda_headers_available(), - reason="need CUDA header", -) diff --git a/cuda_core/tests/example_tests/test_basic_examples.py b/cuda_core/tests/example_tests/test_basic_examples.py index a8a47791991..bf423758366 100644 --- a/cuda_core/tests/example_tests/test_basic_examples.py +++ b/cuda_core/tests/example_tests/test_basic_examples.py @@ -11,17 +11,11 @@ import warnings import pytest +from cuda_python_test_helpers.pep723 import has_package_requirements_or_skip from cuda.core import Device, ManagedMemoryResource, system from cuda.core._program import _can_load_generated_ptx -try: - from cuda.bindings._test_helpers.pep723 import has_package_requirements_or_skip -except ImportError: - # If the import fails, we define a dummy function that will cause all tests to be skipped. - def has_package_requirements_or_skip(example): - pytest.skip("PEP 723 test helper is not available") - def has_compute_capability_9_or_higher() -> bool: return Device().compute_capability >= (9, 0) diff --git a/cuda_core/tests/graph/test_device_launch.py b/cuda_core/tests/graph/test_device_launch.py index 221b09bd815..d77ceeec37f 100644 --- a/cuda_core/tests/graph/test_device_launch.py +++ b/cuda_core/tests/graph/test_device_launch.py @@ -5,7 +5,7 @@ import numpy as np import pytest -from helpers.marks import requires_module +from cuda_python_test_helpers.marks import requires_module from cuda.core import ( Device, diff --git a/cuda_core/tests/graph/test_graph_builder.py b/cuda_core/tests/graph/test_graph_builder.py index 443399c4590..6c7c9ef7d64 100644 --- a/cuda_core/tests/graph/test_graph_builder.py +++ b/cuda_core/tests/graph/test_graph_builder.py @@ -9,8 +9,8 @@ import numpy as np import pytest +from cuda_python_test_helpers.marks import requires_module from helpers.graph_kernels import compile_common_kernels, compile_conditional_kernels -from helpers.marks import requires_module from helpers.misc import try_create_condition from cuda.core import Device, LaunchConfig, LegacyPinnedMemoryResource, launch diff --git a/cuda_core/tests/graph/test_graph_builder_conditional.py b/cuda_core/tests/graph/test_graph_builder_conditional.py index 0bb779a8bf7..150d43bfc14 100644 --- a/cuda_core/tests/graph/test_graph_builder_conditional.py +++ b/cuda_core/tests/graph/test_graph_builder_conditional.py @@ -7,8 +7,8 @@ import numpy as np import pytest +from cuda_python_test_helpers.marks import requires_module from helpers.graph_kernels import compile_conditional_kernels -from helpers.marks import requires_module from cuda.core import Device, LaunchConfig, LegacyPinnedMemoryResource, launch from cuda.core.graph import GraphBuilder diff --git a/cuda_core/tests/graph/test_graph_definition.py b/cuda_core/tests/graph/test_graph_definition.py index 1d63504c7c4..9459cfb4e95 100644 --- a/cuda_core/tests/graph/test_graph_definition.py +++ b/cuda_core/tests/graph/test_graph_definition.py @@ -7,10 +7,10 @@ from dataclasses import dataclass, field import pytest +from conftest import xfail_on_graph_mempool_oom from helpers.graph_kernels import compile_common_kernels from helpers.misc import try_create_condition -from conftest import xfail_on_graph_mempool_oom from cuda.core import Device, LaunchConfig from cuda.core.graph import ( AllocNode, diff --git a/cuda_core/tests/graph/test_graph_definition_errors.py b/cuda_core/tests/graph/test_graph_definition_errors.py index a8a3c9b8f09..d80118cdf7c 100644 --- a/cuda_core/tests/graph/test_graph_definition_errors.py +++ b/cuda_core/tests/graph/test_graph_definition_errors.py @@ -6,10 +6,10 @@ import ctypes import pytest +from conftest import xfail_on_graph_mempool_oom from helpers.graph_kernels import compile_common_kernels from helpers.misc import try_create_condition -from conftest import xfail_on_graph_mempool_oom from cuda.core import Device, LaunchConfig from cuda.core._utils.cuda_utils import CUDAError from cuda.core.graph import ( diff --git a/cuda_core/tests/graph/test_graph_definition_integration.py b/cuda_core/tests/graph/test_graph_definition_integration.py index 12b57bb73a5..58f96e1bab3 100644 --- a/cuda_core/tests/graph/test_graph_definition_integration.py +++ b/cuda_core/tests/graph/test_graph_definition_integration.py @@ -7,8 +7,8 @@ import numpy as np import pytest - from conftest import xfail_on_graph_mempool_oom + from cuda.core import Device, EventOptions, LaunchConfig, Program, ProgramOptions from cuda.core._utils.cuda_utils import driver, handle_return from cuda.core.graph import GraphDefinition diff --git a/cuda_core/tests/graph/test_graph_definition_lifetime.py b/cuda_core/tests/graph/test_graph_definition_lifetime.py index 1364f437ea6..93c1453753d 100644 --- a/cuda_core/tests/graph/test_graph_definition_lifetime.py +++ b/cuda_core/tests/graph/test_graph_definition_lifetime.py @@ -13,10 +13,10 @@ import weakref import pytest +from conftest import xfail_on_graph_mempool_oom from helpers.graph_kernels import compile_common_kernels from helpers.misc import try_create_condition -from conftest import xfail_on_graph_mempool_oom from cuda_python_test_helpers import under_compute_sanitizer # Resource finalization triggered by graph destruction is not synchronous. A diff --git a/cuda_core/tests/graph/test_graph_definition_mutation.py b/cuda_core/tests/graph/test_graph_definition_mutation.py index 066822f232a..eb1f0255ad4 100644 --- a/cuda_core/tests/graph/test_graph_definition_mutation.py +++ b/cuda_core/tests/graph/test_graph_definition_mutation.py @@ -8,9 +8,9 @@ import numpy as np import pytest +from cuda_python_test_helpers.marks import requires_module from helpers.collection_interface_testers import assert_mutable_set_interface from helpers.graph_kernels import compile_parallel_kernels -from helpers.marks import requires_module from cuda.core import Device, LaunchConfig, LegacyPinnedMemoryResource from cuda.core._utils.cuda_utils import CUDAError diff --git a/cuda_core/tests/graph/test_graph_memory_resource.py b/cuda_core/tests/graph/test_graph_memory_resource.py index 9fc794f4cca..517f9c080b7 100644 --- a/cuda_core/tests/graph/test_graph_memory_resource.py +++ b/cuda_core/tests/graph/test_graph_memory_resource.py @@ -5,10 +5,9 @@ """Tests for GraphMemoryResource allocation and attributes during graph capture.""" import pytest -from helpers import IS_WINDOWS, IS_WSL +from conftest import xfail_on_graph_mempool_oom from helpers.buffers import compare_buffer_to_constant, make_scratch_buffer, set_buffer -from conftest import xfail_on_graph_mempool_oom from cuda.core import ( Device, DeviceMemoryResource, @@ -20,6 +19,7 @@ ) from cuda.core._utils.cuda_utils import CUDAError from cuda.core.graph import GraphCompleteOptions +from cuda_python_test_helpers import IS_WINDOWS, IS_WSL def _common_kernels_alloc(): diff --git a/cuda_core/tests/graph/test_graph_update.py b/cuda_core/tests/graph/test_graph_update.py index 13513830944..54a04863cf4 100644 --- a/cuda_core/tests/graph/test_graph_update.py +++ b/cuda_core/tests/graph/test_graph_update.py @@ -9,8 +9,8 @@ import numpy as np import pytest +from cuda_python_test_helpers.marks import requires_module from helpers.graph_kernels import compile_common_kernels, compile_conditional_kernels -from helpers.marks import requires_module from cuda.core import Device, LaunchConfig, LegacyPinnedMemoryResource, launch from cuda.core._utils.cuda_utils import CUDAError diff --git a/cuda_core/tests/memory/test_managed_ops.py b/cuda_core/tests/memory/test_managed_ops.py index 33def77935f..ed7f44a97f4 100644 --- a/cuda_core/tests/memory/test_managed_ops.py +++ b/cuda_core/tests/memory/test_managed_ops.py @@ -4,9 +4,9 @@ import mmap import pytest +from conftest import create_managed_memory_resource_or_skip from helpers.buffers import DummyDeviceMemoryResource, DummyUnifiedMemoryResource -from conftest import create_managed_memory_resource_or_skip from cuda.bindings import driver from cuda.core import Device, Host, ManagedBuffer from cuda.core._memory._managed_buffer import _get_int_attr diff --git a/cuda_core/tests/system/conftest.py b/cuda_core/tests/system/conftest.py deleted file mode 100644 index 8708b3f06fc..00000000000 --- a/cuda_core/tests/system/conftest.py +++ /dev/null @@ -1,28 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# SPDX-License-Identifier: Apache-2.0 - - -import pytest - -from cuda.core import system - -SHOULD_SKIP_NVML_TESTS = not system.CUDA_BINDINGS_NVML_IS_COMPATIBLE - - -if system.CUDA_BINDINGS_NVML_IS_COMPATIBLE: - from cuda.bindings._test_helpers.arch_check import hardware_supports_nvml - - SHOULD_SKIP_NVML_TESTS |= not hardware_supports_nvml() - - -skip_if_nvml_unsupported = pytest.mark.skipif( - SHOULD_SKIP_NVML_TESTS, - reason="NVML support requires cuda.bindings version 12.9.6+ for CUDA 12.x or 13.2.0+ for CUDA 13.x, and hardware that supports NVML", -) - - -def unsupported_before(device, expected_device_arch): - from cuda.bindings._test_helpers.arch_check import unsupported_before as nvml_unsupported_before - - return nvml_unsupported_before(device._handle, expected_device_arch) diff --git a/cuda_core/tests/system/test_nvml_context.py b/cuda_core/tests/system/test_nvml_context.py index 16bc97f385c..03c3fbefe8b 100644 --- a/cuda_core/tests/system/test_nvml_context.py +++ b/cuda_core/tests/system/test_nvml_context.py @@ -1,9 +1,9 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # # SPDX-License-Identifier: Apache-2.0 -from .conftest import skip_if_nvml_unsupported +from cuda_python_test_helpers.arch_check import skip_if_nvml_unsupported pytestmark = skip_if_nvml_unsupported diff --git a/cuda_core/tests/system/test_system_device.py b/cuda_core/tests/system/test_system_device.py index a4722d05cbb..3b2131548b9 100644 --- a/cuda_core/tests/system/test_system_device.py +++ b/cuda_core/tests/system/test_system_device.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 -from .conftest import skip_if_nvml_unsupported, unsupported_before +from cuda_python_test_helpers.arch_check import skip_if_nvml_unsupported, unsupported_before pytestmark = skip_if_nvml_unsupported diff --git a/cuda_core/tests/system/test_system_events.py b/cuda_core/tests/system/test_system_events.py index ce204001a4e..d2684bebd0b 100644 --- a/cuda_core/tests/system/test_system_events.py +++ b/cuda_core/tests/system/test_system_events.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 -from .conftest import skip_if_nvml_unsupported +from cuda_python_test_helpers.arch_check import skip_if_nvml_unsupported pytestmark = skip_if_nvml_unsupported diff --git a/cuda_core/tests/system/test_system_system.py b/cuda_core/tests/system/test_system_system.py index 460078918f5..28173836ff4 100644 --- a/cuda_core/tests/system/test_system_system.py +++ b/cuda_core/tests/system/test_system_system.py @@ -6,13 +6,12 @@ import os import pytest +from cuda_python_test_helpers.arch_check import skip_if_nvml_unsupported from cuda.bindings import driver from cuda.core import system from cuda.core._utils.cuda_utils import handle_return -from .conftest import skip_if_nvml_unsupported - def test_user_mode_driver_version(): umd = system.get_user_mode_driver_version() diff --git a/cuda_core/tests/test_device.py b/cuda_core/tests/test_device.py index 6971911cec5..4cbd28398f3 100644 --- a/cuda_core/tests/test_device.py +++ b/cuda_core/tests/test_device.py @@ -27,7 +27,7 @@ def test_to_system_device(deinit_cuda): device.to_system_device() pytest.skip("NVML support requires cuda.bindings version 12.9.6+ for CUDA 12.x or 13.2.0+ for CUDA 13.x") - from cuda.bindings._test_helpers.arch_check import hardware_supports_nvml + from cuda_python_test_helpers.arch_check import hardware_supports_nvml if not hardware_supports_nvml(): pytest.skip("NVML not supported on this platform") diff --git a/cuda_core/tests/test_launcher.py b/cuda_core/tests/test_launcher.py index 08f2c9e041d..04fd714aa96 100644 --- a/cuda_core/tests/test_launcher.py +++ b/cuda_core/tests/test_launcher.py @@ -4,7 +4,7 @@ import ctypes import helpers -from helpers.marks import requires_module +from cuda_python_test_helpers.marks import requires_module from helpers.misc import StreamWrapper try: @@ -13,8 +13,8 @@ cp = None import numpy as np import pytest - from conftest import skipif_need_cuda_headers + from cuda.core import ( Device, DeviceMemoryResource, diff --git a/cuda_core/tests/test_managed_memory_warning.py b/cuda_core/tests/test_managed_memory_warning.py index 01dd840e2ef..f0596db2fdf 100644 --- a/cuda_core/tests/test_managed_memory_warning.py +++ b/cuda_core/tests/test_managed_memory_warning.py @@ -11,9 +11,9 @@ import warnings import pytest +from conftest import create_managed_memory_resource_or_skip, xfail_if_mempool_oom import cuda.bindings -from conftest import create_managed_memory_resource_or_skip, xfail_if_mempool_oom from cuda.core import Device, ManagedMemoryResource, ManagedMemoryResourceOptions from cuda.core._memory._managed_memory_resource import reset_concurrent_access_warning from cuda.core._utils.cuda_utils import CUDAError diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index 4427b899765..24768d8d1e5 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -14,15 +14,15 @@ import re import pytest -from helpers import IS_WINDOWS, supports_ipc_mempool -from helpers.buffers import DummyDeviceMemoryResource, DummyUnifiedMemoryResource, TrackingMR - from conftest import ( create_managed_memory_resource_or_skip, create_pinned_memory_resource_or_xfail, skip_if_managed_memory_unsupported, skip_if_pinned_memory_unsupported, ) +from helpers import supports_ipc_mempool +from helpers.buffers import DummyDeviceMemoryResource, DummyUnifiedMemoryResource, TrackingMR + from cuda.core import ( Buffer, Device, @@ -53,6 +53,7 @@ VirtualMemoryLocationType, ) from cuda.core.utils import StridedMemoryView +from cuda_python_test_helpers import IS_WINDOWS POOL_SIZE = 2097152 # 2MB size diff --git a/cuda_core/tests/test_object_protocols.py b/cuda_core/tests/test_object_protocols.py index e8391c75678..f843f451683 100644 --- a/cuda_core/tests/test_object_protocols.py +++ b/cuda_core/tests/test_object_protocols.py @@ -13,10 +13,10 @@ import weakref import pytest +from conftest import xfail_on_graph_mempool_oom from helpers.graph_kernels import compile_common_kernels from helpers.misc import try_create_condition -from conftest import xfail_on_graph_mempool_oom from cuda.core import ( Buffer, Device, diff --git a/cuda_core/tests/test_tensor_map.py b/cuda_core/tests/test_tensor_map.py index 8670e910075..6f63938710f 100644 --- a/cuda_core/tests/test_tensor_map.py +++ b/cuda_core/tests/test_tensor_map.py @@ -3,8 +3,8 @@ import numpy as np import pytest - from conftest import create_managed_memory_resource_or_skip, skip_if_managed_memory_unsupported + from cuda.core import ( Device, ManagedMemoryResourceOptions, diff --git a/cuda_core/tests/test_utils.py b/cuda_core/tests/test_utils.py index e637aac0a0f..c0dffc5a323 100644 --- a/cuda_core/tests/test_utils.py +++ b/cuda_core/tests/test_utils.py @@ -27,7 +27,7 @@ ml_dtypes = None import numpy as np import pytest -from helpers.marks import requires_module +from cuda_python_test_helpers.marks import requires_module from cuda.core import Device from cuda.core._dlpack import DLDeviceType diff --git a/cuda_pathfinder/tests/test_driver_lib_loading.py b/cuda_pathfinder/tests/test_driver_lib_loading.py index b97453c9b5a..9436736310c 100644 --- a/cuda_pathfinder/tests/test_driver_lib_loading.py +++ b/cuda_pathfinder/tests/test_driver_lib_loading.py @@ -15,8 +15,8 @@ build_child_process_failed_for_libname_message, run_load_nvidia_dynamic_lib_in_subprocess, ) - from conftest import skip_if_missing_libnvcudla_so + from cuda.pathfinder._dynamic_libs.lib_descriptor import LIB_DESCRIPTORS from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError, LoadedDL from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import ( diff --git a/cuda_pathfinder/tests/test_find_nvidia_headers.py b/cuda_pathfinder/tests/test_find_nvidia_headers.py index 90fe3cf9815..20190725884 100644 --- a/cuda_pathfinder/tests/test_find_nvidia_headers.py +++ b/cuda_pathfinder/tests/test_find_nvidia_headers.py @@ -20,9 +20,9 @@ from pathlib import Path import pytest +from conftest import skip_if_missing_libnvcudla_so import cuda.pathfinder._headers.find_nvidia_headers as find_nvidia_headers_module -from conftest import skip_if_missing_libnvcudla_so from cuda.pathfinder import LocatedHeaderDir, find_nvidia_header_directory, locate_nvidia_header_directory from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import ( _resolve_system_loaded_abs_path_in_subprocess, diff --git a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py index ad42e24e63e..810ddc71aa0 100644 --- a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py +++ b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py @@ -9,9 +9,9 @@ build_child_process_failed_for_libname_message, run_load_nvidia_dynamic_lib_in_subprocess, ) +from conftest import skip_if_missing_libnvcudla_so from local_helpers import have_distribution -from conftest import skip_if_missing_libnvcudla_so from cuda.pathfinder import DynamicLibNotAvailableError, DynamicLibUnknownError, load_nvidia_dynamic_lib from cuda.pathfinder._dynamic_libs import load_nvidia_dynamic_lib as load_nvidia_dynamic_lib_module from cuda.pathfinder._dynamic_libs import supported_nvidia_libs diff --git a/cuda_python_test_helpers/cuda_python_test_helpers/__init__.py b/cuda_python_test_helpers/cuda_python_test_helpers/__init__.py index 342c2477ffc..c67162483f5 100644 --- a/cuda_python_test_helpers/cuda_python_test_helpers/__init__.py +++ b/cuda_python_test_helpers/cuda_python_test_helpers/__init__.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 import ctypes @@ -8,6 +8,7 @@ from contextlib import suppress __all__ = [ + "IS_LINUX", "IS_WINDOWS", "IS_WSL", "libc", @@ -26,6 +27,7 @@ def _detect_wsl() -> bool: IS_WSL: bool = _detect_wsl() IS_WINDOWS: bool = platform.system() == "Windows" or sys.platform.startswith("win") +IS_LINUX: bool = not IS_WINDOWS and not IS_WSL and platform.system() == "Linux" if IS_WINDOWS: libc = ctypes.CDLL("msvcrt.dll") diff --git a/conftest.py b/cuda_python_test_helpers/cuda_python_test_helpers/_pytest_plugin.py similarity index 72% rename from conftest.py rename to cuda_python_test_helpers/cuda_python_test_helpers/_pytest_plugin.py index 7a0c59065d5..e1da55dcaf0 100644 --- a/conftest.py +++ b/cuda_python_test_helpers/cuda_python_test_helpers/_pytest_plugin.py @@ -1,27 +1,18 @@ # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 +"""Pytest plugin registered via the ``pytest11`` entry point. -import os +Automatically tags collected items with package markers and gates cython +tests on CUDA header availability. Loaded by pytest whenever +``cuda-python-test-helpers`` is installed, and also explicitly via +``pytest_plugins`` in each subpackage conftest so the fallback sys.path +install path is covered too. +""" import pytest -from cuda.pathfinder import get_cuda_path_or_home - - -# Please keep in sync with the copy in cuda_core/tests/conftest.py. -def _cuda_headers_available() -> bool: - """Return True if CUDA headers are available, False if no CUDA path is set. - - Raises AssertionError if a CUDA path is set but has no include/ subdirectory. - """ - cuda_path = get_cuda_path_or_home() - if cuda_path is None: - return False - assert os.path.isdir(os.path.join(cuda_path, "include")), ( - f"CUDA path {cuda_path} does not contain an 'include' subdirectory" - ) - return True +from cuda_python_test_helpers.marks import _cuda_headers_available def pytest_collection_modifyitems(config, items): # noqa: ARG001 diff --git a/cuda_python_test_helpers/cuda_python_test_helpers/arch_check.py b/cuda_python_test_helpers/cuda_python_test_helpers/arch_check.py new file mode 100644 index 00000000000..adb3563821f --- /dev/null +++ b/cuda_python_test_helpers/cuda_python_test_helpers/arch_check.py @@ -0,0 +1,93 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +from contextlib import contextmanager +from functools import cache + +import pytest + + +@cache +def hardware_supports_nvml(): + """Try the simplest NVML API to verify basic functionality. + + Returns False on platforms where NVML is unsupported (e.g. Jetson Orin). + """ + from cuda.bindings import nvml + from cuda.bindings._internal.utils import FunctionNotFoundError as NvmlSymbolNotFoundError # noqa: F401 + + nvml.init_v2() + try: + nvml.system_get_driver_branch() + except (nvml.NotSupportedError, nvml.UnknownError): + return False + else: + return True + finally: + nvml.shutdown() + + +def _should_skip_nvml_tests() -> bool: + """Return True if NVML tests should be skipped on this system. + + Checks cuda.core's compatibility gate first (if cuda.core is installed), + then falls back to a hardware-level NVML probe. + """ + try: + from cuda.core import system + + if not system.CUDA_BINDINGS_NVML_IS_COMPATIBLE: + return True + except ImportError: + pass # cuda.core not installed; skip the compat gate + return not hardware_supports_nvml() + + +skip_if_nvml_unsupported = pytest.mark.skipif( + _should_skip_nvml_tests(), + reason="NVML support requires cuda.bindings version 12.9.6+ for CUDA 12.x or 13.2.0+ for CUDA 13.x, and hardware that supports NVML", +) + + +@contextmanager +def unsupported_before(device, expected_device_arch): + """Context manager that skips or xfails when an NVML API is not supported on this device. + + ``device`` may be a raw NVML device handle (int) or any object that exposes + the handle via a ``._handle`` attribute (e.g. ``cuda.core.system.Device``). + """ + from cuda.bindings import nvml + from cuda.bindings._internal.utils import FunctionNotFoundError as NvmlSymbolNotFoundError + + handle = getattr(device, "_handle", device) + device_arch = nvml.device_get_architecture(handle) + + if isinstance(expected_device_arch, nvml.DeviceArch): + expected_device_arch_int = int(expected_device_arch) + elif expected_device_arch == "FERMI": + expected_device_arch_int = 1 + else: + expected_device_arch_int = 0 + + if expected_device_arch is None or expected_device_arch == "HAS_INFOROM" or device_arch == nvml.DeviceArch.UNKNOWN: + # We don't know if it will fail, so we tolerate either outcome. + # + # TODO: There are APIs that are documented as supported only if the + # device has an InfoROM, but I couldn't find a way to detect that. For + # now, they are just handled as "possibly failing". + try: + yield + except (nvml.NotSupportedError, nvml.FunctionNotFoundError, NvmlSymbolNotFoundError): + pytest.skip( + f"Unsupported call for device architecture {nvml.DeviceArch(device_arch).name} " + f"on device '{nvml.device_get_name(handle)}'" + ) + elif int(device_arch) < expected_device_arch_int: + # We know it will fail; assert that it does. + with pytest.raises(nvml.NotSupportedError): + yield + pytest.skip(f"Unsupported before {expected_device_arch.name}, got {nvml.device_get_name(handle)}") + else: + yield diff --git a/cuda_core/tests/helpers/marks.py b/cuda_python_test_helpers/cuda_python_test_helpers/marks.py similarity index 66% rename from cuda_core/tests/helpers/marks.py rename to cuda_python_test_helpers/cuda_python_test_helpers/marks.py index 53fcc544eb7..03d6ff2b622 100644 --- a/cuda_core/tests/helpers/marks.py +++ b/cuda_python_test_helpers/cuda_python_test_helpers/marks.py @@ -1,12 +1,15 @@ # SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 -"""Reusable pytest marks for cuda_core tests.""" +"""Reusable pytest marks and skip helpers for CUDA Python test suites.""" import inspect +import os import pytest +from cuda.pathfinder import get_cuda_path_or_home + def requires_module(module, *args, **kwargs): """Skip the test if a module is missing or older than required. @@ -43,3 +46,23 @@ def test_bar(): ... return pytest.mark.skipif(True, reason=str(exc)) else: return pytest.mark.skipif(False, reason="") + + +def _cuda_headers_available() -> bool: + """Return True if CUDA headers are available, False if no CUDA path is set. + + Raises AssertionError if a CUDA path is set but has no include/ subdirectory. + """ + cuda_path = get_cuda_path_or_home() + if cuda_path is None: + return False + assert os.path.isdir(os.path.join(cuda_path, "include")), ( + f"CUDA path {cuda_path} does not contain an 'include' subdirectory" + ) + return True + + +skipif_need_cuda_headers = pytest.mark.skipif( + not _cuda_headers_available(), + reason="need CUDA header", +) diff --git a/cuda_bindings/cuda/bindings/_test_helpers/mempool.py b/cuda_python_test_helpers/cuda_python_test_helpers/mempool.py similarity index 84% rename from cuda_bindings/cuda/bindings/_test_helpers/mempool.py rename to cuda_python_test_helpers/cuda_python_test_helpers/mempool.py index e2a61e48c53..c1fad576da9 100644 --- a/cuda_bindings/cuda/bindings/_test_helpers/mempool.py +++ b/cuda_python_test_helpers/cuda_python_test_helpers/mempool.py @@ -5,16 +5,11 @@ import pytest -from cuda.bindings import driver, runtime - -# Keep in sync with the fallback in cuda_core/tests/conftest.py. The cuda_core -# copy is intentionally simpler because it only handles cuda_core CUDAError -# exceptions when this helper is absent from older published bindings. def is_windows_mcdm_device(device=0): if sys.platform != "win32": return False - import cuda.bindings.nvml as nvml + from cuda.bindings import driver, nvml device_id = int(getattr(device, "device_id", device)) (err,) = driver.cuInit(0) @@ -34,6 +29,8 @@ def is_windows_mcdm_device(device=0): def xfail_if_mempool_oom(err_or_exc, api_name=None, device=0): + from cuda.bindings import driver, runtime + if api_name is not None and not isinstance(api_name, str): device = api_name api_name = None diff --git a/cuda_bindings/cuda/bindings/_test_helpers/pep723.py b/cuda_python_test_helpers/cuda_python_test_helpers/pep723.py similarity index 100% rename from cuda_bindings/cuda/bindings/_test_helpers/pep723.py rename to cuda_python_test_helpers/cuda_python_test_helpers/pep723.py From 8fe6c246c1758afa7d43f442bb3b8baadd9bfb17 Mon Sep 17 00:00:00 2001 From: Jinfeng Li Date: Tue, 4 Aug 2026 16:51:57 -0400 Subject: [PATCH 25/50] docs: update nvshmem4py link to /api/latest/ path (#2492) NVSHMEM docs now live under /nvshmem/api/latest/; the old unversioned deep link 404s and breaks lychee on rendered docs. --- README.md | 2 +- cuda_python/DESCRIPTION.rst | 2 +- cuda_python/docs/source/index.rst | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 782f04269ad..10d0bc6a0cf 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ CUDA Python is the home for accessing NVIDIA’s CUDA platform from Python. It c * [numba.cuda](https://nvidia.github.io/numba-cuda/): A Python DSL that exposes CUDA **SIMT** programming model and compiles a restricted subset of Python code into CUDA kernels and device functions * [cuda.tile](https://docs.nvidia.com/cuda/cutile-python/): A new Python DSL that exposes CUDA **Tile** programming model and allows users to write NumPy-like code in CUDA kernels * [nvmath-python](https://docs.nvidia.com/cuda/nvmath-python/latest): Pythonic access to NVIDIA CPU & GPU Math Libraries, with [*host*](https://docs.nvidia.com/cuda/nvmath-python/latest/overview.html#host-apis), [*device*](https://docs.nvidia.com/cuda/nvmath-python/latest/overview.html#device-apis), and [*distributed*](https://docs.nvidia.com/cuda/nvmath-python/latest/distributed-apis/index.html) APIs. It also provides low-level Python bindings to host C APIs ([nvmath.bindings](https://docs.nvidia.com/cuda/nvmath-python/latest/bindings/index.html)). -* [nvshmem4py](https://docs.nvidia.com/nvshmem/api/api/language_bindings/python/index.html): Pythonic interface to the NVSHMEM library, enabling Python applications to leverage NVSHMEM's high-performance PGAS (Partitioned Global Address Space) programming model for GPU-accelerated computing +* [nvshmem4py](https://docs.nvidia.com/nvshmem/api/latest/api/language_bindings/python/index.html): Pythonic interface to the NVSHMEM library, enabling Python applications to leverage NVSHMEM's high-performance PGAS (Partitioned Global Address Space) programming model for GPU-accelerated computing * [Nsight Python](https://docs.nvidia.com/nsight-python/index.html): Python kernel profiling interface that automates performance analysis across multiple kernel configurations using NVIDIA Nsight Tools * [CUPTI Python](https://docs.nvidia.com/cupti-python/): Python APIs for creation of profiling tools that target CUDA Python applications via the CUDA Profiling Tools Interface (CUPTI) * [Accelerated Computing Hub](https://github.com/NVIDIA/accelerated-computing-hub): Open-source learning materials related to GPU computing. You will find user guides, tutorials, and other works freely available for all learners interested in GPU computing. diff --git a/cuda_python/DESCRIPTION.rst b/cuda_python/DESCRIPTION.rst index 3f0a92b5af6..79fa69584ff 100644 --- a/cuda_python/DESCRIPTION.rst +++ b/cuda_python/DESCRIPTION.rst @@ -15,7 +15,7 @@ CUDA Python is the home for accessing NVIDIA's CUDA platform from Python. It con * `numba.cuda `_: A Python DSL that exposes CUDA **SIMT** programming model and compiles a restricted subset of Python code into CUDA kernels and device functions * `cuda.tile `_: A new Python DSL that exposes CUDA **Tile** programming model and allows users to write NumPy-like code in CUDA kernels * `nvmath-python `_: Pythonic access to NVIDIA CPU & GPU Math Libraries, with `host `_, `device `_, and `distributed `_ APIs. It also provides low-level Python bindings to host C APIs (`nvmath.bindings `_). -* `nvshmem4py `_: Pythonic interface to the NVSHMEM library, enabling Python applications to leverage NVSHMEM's high-performance PGAS (Partitioned Global Address Space) programming model for GPU-accelerated computing +* `nvshmem4py `_: Pythonic interface to the NVSHMEM library, enabling Python applications to leverage NVSHMEM's high-performance PGAS (Partitioned Global Address Space) programming model for GPU-accelerated computing * `Nsight Python `_: Python kernel profiling interface that automates performance analysis across multiple kernel configurations using NVIDIA Nsight Tools * `CUPTI Python `_: Python APIs for creation of profiling tools that target CUDA Python applications via the CUDA Profiling Tools Interface (CUPTI) * `Accelerated Computing Hub `_: Open-source learning materials related to GPU computing. You will find user guides, tutorials, and other works freely available for all learners interested in GPU computing. diff --git a/cuda_python/docs/source/index.rst b/cuda_python/docs/source/index.rst index 472a9bee90f..199758f0cf8 100644 --- a/cuda_python/docs/source/index.rst +++ b/cuda_python/docs/source/index.rst @@ -29,7 +29,7 @@ multiple components: .. _device: https://docs.nvidia.com/cuda/nvmath-python/latest/overview.html#device-apis .. _distributed: https://docs.nvidia.com/cuda/nvmath-python/latest/distributed-apis/index.html .. _nvmath.bindings: https://docs.nvidia.com/cuda/nvmath-python/latest/bindings/index.html -.. _nvshmem4py: https://docs.nvidia.com/nvshmem/api/api/language_bindings/python/index.html +.. _nvshmem4py: https://docs.nvidia.com/nvshmem/api/latest/api/language_bindings/python/index.html .. _Nsight Python: https://docs.nvidia.com/nsight-python/index.html .. _CUPTI Python: https://docs.nvidia.com/cupti-python/ .. _Accelerated Computing Hub: https://github.com/NVIDIA/accelerated-computing-hub @@ -55,7 +55,7 @@ be available, please refer to the `cuda.bindings`_ documentation for installatio numba.cuda cuda.tile nvmath-python - nvshmem4py + nvshmem4py Nsight Python CUPTI Python Accelerated Computing Hub From 4fe801cd32ac9d1cadc443aa09954bd6661d4708 Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Tue, 4 Aug 2026 14:48:38 -0700 Subject: [PATCH 26/50] Add mitigations for intermittent test failures with CUDA OOM (#2484) * Add context sync to teardown in init_cuda fixture * Cap memory pool size in some tests --- cuda_core/tests/conftest.py | 13 +++++++++++++ cuda_core/tests/test_memory.py | 10 +++++++--- cuda_core/tests/test_memory_peer_access.py | 16 ++++++++++++---- 3 files changed, 32 insertions(+), 7 deletions(-) diff --git a/cuda_core/tests/conftest.py b/cuda_core/tests/conftest.py index 34498df83fc..e012e349d27 100644 --- a/cuda_core/tests/conftest.py +++ b/cuda_core/tests/conftest.py @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 import functools +import gc import importlib import multiprocessing import os @@ -68,6 +69,18 @@ def _init_cuda_context(): try: yield device finally: + # Force any pool/allocation whose only remaining reference was a local + # in this test's frame to actually get destroyed now, then drain the + # context so the stream-ordered frees that destruction enqueues retire + # before the next test runs. Without this, a memory pool's VA + # reservation is not returned until both have happened, and per-test + # leftovers accumulate across the run -- which is how full-suite runs + # can exhaust address space and hit CUDA_ERROR_OUT_OF_MEMORY on a + # device with plenty of free physical memory (issue #2381). gc.collect() + # must run first: cuCtxSynchronize alone cannot drain frees that were + # never enqueued because their owning object had not been collected yet. + gc.collect() + driver.cuCtxSynchronize() _ = _device_unset_current() diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index 24768d8d1e5..98baa521ef2 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -1453,11 +1453,13 @@ def test_pinned_mr_numa_id_default_no_ipc(init_cuda): device = Device() skip_if_pinned_memory_unsupported(device) - mr = create_pinned_memory_resource_or_xfail(PinnedMemoryResourceOptions(), xfail_device=device) + mr = create_pinned_memory_resource_or_xfail(PinnedMemoryResourceOptions(max_size=POOL_SIZE), xfail_device=device) assert mr.numa_id == -1 mr.close() - mr = create_pinned_memory_resource_or_xfail(PinnedMemoryResourceOptions(ipc_enabled=False), xfail_device=device) + mr = create_pinned_memory_resource_or_xfail( + PinnedMemoryResourceOptions(ipc_enabled=False, max_size=POOL_SIZE), xfail_device=device + ) assert mr.numa_id == -1 mr.close() @@ -1492,7 +1494,9 @@ def test_pinned_mr_numa_id_explicit(init_cuda): if host_numa_id < 0: pytest.skip("System does not support NUMA") - mr = create_pinned_memory_resource_or_xfail(PinnedMemoryResourceOptions(numa_id=host_numa_id), xfail_device=device) + mr = create_pinned_memory_resource_or_xfail( + PinnedMemoryResourceOptions(numa_id=host_numa_id, max_size=POOL_SIZE), xfail_device=device + ) assert mr.numa_id == host_numa_id mr.close() diff --git a/cuda_core/tests/test_memory_peer_access.py b/cuda_core/tests/test_memory_peer_access.py index 68c32ce69c6..2cbfbbd302f 100644 --- a/cuda_core/tests/test_memory_peer_access.py +++ b/cuda_core/tests/test_memory_peer_access.py @@ -11,6 +11,14 @@ from cuda.core._utils.cuda_utils import CUDAError NBYTES = 1024 +# Every owned pool below holds at most NBYTES, but a pool created without an +# explicit max_size reserves a system-dependent window that scales with device +# memory -- hundreds of GiB on large-memory GPUs. The per-process virtual +# address budget is bounded (~1 TB on Windows MCDM), and reservations are not +# returned until a pool is torn down and its stream-ordered frees retire, so +# oversized windows accumulate across a session and eventually starve later +# pool creations with CUDA_ERROR_OUT_OF_MEMORY (issue #2381). Cap them. +POOL_SIZE = 2097152 # 2MB size pytestmark = pytest.mark.thread_unsafe(reason="peer access tests mutate process-global CUDA memory-pool access state") @@ -22,7 +30,7 @@ def test_peer_access_basic(mempool_device_x2): one_on_dev0 = make_scratch_buffer(dev0, 1, NBYTES) stream_on_dev0 = dev0.create_stream() # Use owned pool to ensure clean initial state (no stale peer access). - dmr_on_dev1 = DeviceMemoryResource(dev1, DeviceMemoryResourceOptions()) + dmr_on_dev1 = DeviceMemoryResource(dev1, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) buf_on_dev1 = dmr_on_dev1.allocate(NBYTES, stream=dev1.default_stream) # No access at first. @@ -73,7 +81,7 @@ def test_peer_access_transitions(mempool_device_x3): pgens = [PatternGen(devs[i], NBYTES, streams[i]) for i in range(3)] # Use owned pools (with options) to ensure clean initial state. # Default pools are shared and may have stale peer access from prior tests. - dmrs = [DeviceMemoryResource(dev, DeviceMemoryResourceOptions()) for dev in devs] + dmrs = [DeviceMemoryResource(dev, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) for dev in devs] bufs = [dmr.allocate(NBYTES, stream=dev.default_stream) for dmr, dev in zip(dmrs, devs)] def verify_state(state, pattern_seed): @@ -163,7 +171,7 @@ def isolated_dmr_x2(mempool_device_x2): proxy tests are not polluted by other tests sharing a default pool. """ dev0, dev1 = mempool_device_x2 - dmr = DeviceMemoryResource(dev0, DeviceMemoryResourceOptions()) + dmr = DeviceMemoryResource(dev0, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) dmr.peer_accessible_by = [] return dmr, dev0, dev1 @@ -273,7 +281,7 @@ def test_peer_accessible_by_no_cache_across_proxies(mempool_device_x2): def test_peer_accessible_by_iteration_order_is_sorted(mempool_device_x2): """``__iter__`` yields peers in ascending device-ordinal order.""" dev0, dev1 = mempool_device_x2 - dmr = DeviceMemoryResource(dev0, DeviceMemoryResourceOptions()) + dmr = DeviceMemoryResource(dev0, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) dmr.peer_accessible_by = [dev1] devices = list(dmr.peer_accessible_by) ids = [d.device_id for d in devices] From 8d4d072acaf812780632917b6e3f24f3867da9c3 Mon Sep 17 00:00:00 2001 From: Jinfeng Li Date: Tue, 4 Aug 2026 23:39:15 -0400 Subject: [PATCH 27/50] cuda.core: return CUmodule via as_py in ObjectCode.get_module (#2481) * cuda.core: return CUmodule via as_py in ObjectCode.get_module Use the shared handle export path for legacy CUmodule interop instead of constructing driver.CUmodule directly. Signed-off-by: Jinfeng * cuda.core: drop unused intptr_t import in _module.pyx Satisfy cython-lint after switching get_module() to as_py(). Signed-off-by: Jinfeng * cuda.core: add as_intptr overload for CUmodule Route as_py(CUmodule) through as_intptr for consistency with other handle exports. * let as_cu supports CUModule --------- Signed-off-by: Jinfeng --- cuda_core/cuda/core/_cpp/resource_handles.hpp | 12 ++++++++++++ cuda_core/cuda/core/_module.pyi | 2 +- cuda_core/cuda/core/_module.pyx | 5 ++--- cuda_core/cuda/core/_resource_handles.pxd | 3 +++ 4 files changed, 18 insertions(+), 4 deletions(-) diff --git a/cuda_core/cuda/core/_cpp/resource_handles.hpp b/cuda_core/cuda/core/_cpp/resource_handles.hpp index 60a9f3c53a9..f2415cd23ac 100644 --- a/cuda_core/cuda/core/_cpp/resource_handles.hpp +++ b/cuda_core/cuda/core/_cpp/resource_handles.hpp @@ -754,6 +754,10 @@ inline CUlibrary as_cu(const LibraryHandle& h) noexcept { return h ? *h : nullptr; } +inline CUmodule as_cu(const CUmodule& h) noexcept { + return h; +} + inline CUkernel as_cu(const KernelHandle& h) noexcept { return h ? *h : nullptr; } @@ -838,6 +842,10 @@ inline std::intptr_t as_intptr(const LibraryHandle& h) noexcept { return reinterpret_cast(as_cu(h)); } +inline std::intptr_t as_intptr(const CUmodule& h) noexcept { + return reinterpret_cast(as_cu(h)); +} + inline std::intptr_t as_intptr(const KernelHandle& h) noexcept { return reinterpret_cast(as_cu(h)); } @@ -968,6 +976,10 @@ inline PyObject* as_py(const LibraryHandle& h) noexcept { return detail::make_py("cuda.bindings.driver", "CUlibrary", as_intptr(h)); } +inline PyObject* as_py(const CUmodule& h) noexcept { + return detail::make_py("cuda.bindings.driver", "CUmodule", as_intptr(h)); +} + inline PyObject* as_py(const KernelHandle& h) noexcept { return detail::make_py("cuda.bindings.driver", "CUkernel", as_intptr(h)); } diff --git a/cuda_core/cuda/core/_module.pyi b/cuda_core/cuda/core/_module.pyi index f51b4cb2817..9ff758bb6c7 100644 --- a/cuda_core/cuda/core/_module.pyi +++ b/cuda_core/cuda/core/_module.pyi @@ -458,7 +458,7 @@ class ObjectCode: """ - def get_module(self) -> object: + def get_module(self) -> driver.CUmodule: """Return a context-dependent :obj:`~driver.CUmodule` for legacy interop. Bridges the native :obj:`~driver.CUlibrary` (see :attr:`handle`) to a diff --git a/cuda_core/cuda/core/_module.pyx b/cuda_core/cuda/core/_module.pyx index 704f6d2f856..95e149065bf 100644 --- a/cuda_core/cuda/core/_module.pyx +++ b/cuda_core/cuda/core/_module.pyx @@ -6,7 +6,6 @@ from __future__ import annotations cimport cython from libc.stddef cimport size_t -from libc.stdint cimport intptr_t from libcpp.mutex cimport py_safe_call_once from collections import namedtuple @@ -811,7 +810,7 @@ cdef class ObjectCode: HANDLE_RETURN(get_last_error()) return Kernel._from_handle(h_kernel) - def get_module(self) -> object: + def get_module(self) -> driver.CUmodule: """Return a context-dependent :obj:`~driver.CUmodule` for legacy interop. Bridges the native :obj:`~driver.CUlibrary` (see :attr:`handle`) to a @@ -828,7 +827,7 @@ cdef class ObjectCode: cdef cydriver.CUmodule mod with nogil: HANDLE_RETURN(cydriver.cuLibraryGetModule(&mod, as_cu(self._h_library))) - return driver.CUmodule(mod) + return as_py(mod) @property def code(self) -> CodeTypeT: diff --git a/cuda_core/cuda/core/_resource_handles.pxd b/cuda_core/cuda/core/_resource_handles.pxd index b0ae65d1666..168aec3d72e 100644 --- a/cuda_core/cuda/core/_resource_handles.pxd +++ b/cuda_core/cuda/core/_resource_handles.pxd @@ -85,6 +85,7 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": cydriver.CUmemoryPool as_cu(MemoryPoolHandle h) noexcept nogil cydriver.CUdeviceptr as_cu(DevicePtrHandle h) noexcept nogil cydriver.CUlibrary as_cu(LibraryHandle h) noexcept nogil + cydriver.CUmodule as_cu(cydriver.CUmodule h) noexcept nogil cydriver.CUkernel as_cu(KernelHandle h) noexcept nogil cydriver.CUgraph as_cu(GraphHandle h) noexcept nogil cydriver.CUgraphExec as_cu(GraphExecHandle h) noexcept nogil @@ -107,6 +108,7 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": intptr_t as_intptr(MemoryPoolHandle h) noexcept nogil intptr_t as_intptr(DevicePtrHandle h) noexcept nogil intptr_t as_intptr(LibraryHandle h) noexcept nogil + intptr_t as_intptr(const cydriver.CUmodule& h) noexcept nogil intptr_t as_intptr(KernelHandle h) noexcept nogil intptr_t as_intptr(GraphHandle h) noexcept nogil intptr_t as_intptr(GraphExecHandle h) noexcept nogil @@ -130,6 +132,7 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": object as_py(MemoryPoolHandle h) object as_py(DevicePtrHandle h) object as_py(LibraryHandle h) + object as_py(const cydriver.CUmodule& h) object as_py(KernelHandle h) object as_py(GraphHandle h) object as_py(GraphExecHandle h) From 418595b78adb4b693999077ccabd4d7f1cbd2dd9 Mon Sep 17 00:00:00 2001 From: Aryan Putta Date: Wed, 5 Aug 2026 11:49:21 -0400 Subject: [PATCH 28/50] cuda.core: resolve default-stream context per call instead of caching it (#2490) * cuda.core: resolve default-stream context per call instead of caching it LEGACY_DEFAULT_STREAM and PER_THREAD_DEFAULT_STREAM wrap default-stream tokens, which denote whatever context is current. Both are module-level singletons, and Stream_ensure_ctx / Stream_ensure_ctx_device stored the first context and device they observed on the object and never cleared them, so a process-wide object became permanently bound to one context. Replace the two helpers with resolvers that return the context and device through out-parameters and cache on the object only when the stream is not a default-stream token. Stream.context, .device, .resources, .record(), and __repr__ now follow the current context, a query no longer pins a context reference for the lifetime of the process, and the shared singletons are no longer written to from multiple threads. Object identity is preserved, so __eq__ and __hash__ keying off the handle are unaffected. Fixes #2485 * fix(cuda.core): harden default-stream context resolution for #2485 Skip sticky context reuse on default-stream tokens, document ambient context behavior on device/resources/record, and cover resources in the multi-GPU regression test. --------- Co-authored-by: Andy Jost --- cuda_core/cuda/core/_stream.pyi | 37 ++++- cuda_core/cuda/core/_stream.pyx | 126 +++++++++++++----- cuda_core/docs/source/release/1.2.0-notes.rst | 11 ++ cuda_core/tests/test_stream.py | 64 +++++++++ 4 files changed, 201 insertions(+), 37 deletions(-) diff --git a/cuda_core/cuda/core/_stream.pyi b/cuda_core/cuda/core/_stream.pyi index efdcca29256..99af5f9b15b 100644 --- a/cuda_core/cuda/core/_stream.pyi +++ b/cuda_core/cuda/core/_stream.pyi @@ -131,6 +131,13 @@ class Stream: :obj:`~_event.Event` Newly created event object. + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so a newly created event is + associated with the current context at call time. + """ def wait(self, event_or_stream: Event | Stream) -> None: @@ -157,15 +164,29 @@ class Stream: Note ---- - The current context on the device may differ from this - stream's context. This case occurs when a different CUDA - context is set current after a stream is created. + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this returns the device for + the current context at call time. + + For a created stream, the current context on the device may differ from + this stream's context. That case occurs when a different CUDA context is + set current after the stream is created. """ @property def context(self) -> Context: - """Return the :obj:`~_context.Context` associated with this stream.""" + """Return the :obj:`~_context.Context` associated with this stream. + + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this returns the current + context at call time. + + """ @property def resources(self) -> DeviceResources: @@ -174,6 +195,14 @@ class Stream: For streams created from a green context, returns the resources that context was provisioned with. For streams on the primary context, returns the full device resources. + + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this queries the current + context at call time. + """ @staticmethod diff --git a/cuda_core/cuda/core/_stream.pyx b/cuda_core/cuda/core/_stream.pyx index e768f6469f0..c8c5faf74bc 100644 --- a/cuda_core/cuda/core/_stream.pyx +++ b/cuda_core/cuda/core/_stream.pyx @@ -216,8 +216,9 @@ cdef class Stream: return as_intptr(self._h_stream) == as_intptr((other)._h_stream) def __repr__(self) -> str: - Stream_ensure_ctx(self) - return f"" + cdef ContextHandle h_context + Stream_get_ctx(self, &h_context) + return f"" @property def handle(self) -> cuda.bindings.driver.CUstream: @@ -273,13 +274,22 @@ cdef class Stream: :obj:`~_event.Event` Newly created event object. + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so a newly created event is + associated with the current context at call time. + """ # Create an Event object (or reusing the given one) by recording # on the stream. Event flags such as disabling timing, nonblocking, # and CU_EVENT_RECORD_EXTERNAL, can be set in EventOptions. + cdef ContextHandle h_context + cdef int device_id if event is None: - Stream_ensure_ctx_device(self) - event = cyEvent._init(cyEvent, self._device_id, self._h_context, options, False) + Stream_get_ctx_device(self, &h_context, &device_id) + event = cyEvent._init(cyEvent, device_id, h_context, options, False) elif event.is_ipc_enabled: raise TypeError( "IPC-enabled events should not be re-recorded, instead create a " @@ -344,21 +354,38 @@ cdef class Stream: Note ---- - The current context on the device may differ from this - stream's context. This case occurs when a different CUDA - context is set current after a stream is created. + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this returns the device for + the current context at call time. + + For a created stream, the current context on the device may differ from + this stream's context. That case occurs when a different CUDA context is + set current after the stream is created. """ from cuda.core._device import Device # avoid circular import - Stream_ensure_ctx_device(self) - return Device(self._device_id) + cdef ContextHandle h_context + cdef int device_id + Stream_get_ctx_device(self, &h_context, &device_id) + return Device(device_id) @property def context(self) -> Context: - """Return the :obj:`~_context.Context` associated with this stream.""" - Stream_ensure_ctx(self) - Stream_ensure_ctx_device(self) - return Context._from_handle(Context, self._h_context, self._device_id) + """Return the :obj:`~_context.Context` associated with this stream. + + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this returns the current + context at call time. + + """ + cdef ContextHandle h_context + cdef int device_id + Stream_get_ctx_device(self, &h_context, &device_id) + return Context._from_handle(Context, h_context, device_id) @property def resources(self) -> DeviceResources: @@ -367,10 +394,19 @@ cdef class Stream: For streams created from a green context, returns the resources that context was provisioned with. For streams on the primary context, returns the full device resources. + + Note + ---- + A default stream (:obj:`LEGACY_DEFAULT_STREAM` or + :obj:`PER_THREAD_DEFAULT_STREAM`) carries no context of its own; it + refers to whichever context is current, so this queries the current + context at call time. + """ - Stream_ensure_ctx(self) - Stream_ensure_ctx_device(self) - return DeviceResources._init_from_ctx(self._h_context, self._device_id) + cdef ContextHandle h_context + cdef int device_id + Stream_get_ctx_device(self, &h_context, &device_id) + return DeviceResources._init_from_ctx(h_context, device_id) @staticmethod def from_handle(handle) -> Stream: @@ -447,39 +483,63 @@ cpdef Stream default_stream(): return LEGACY_DEFAULT_STREAM -cdef inline int Stream_ensure_ctx(Stream self) except?-1 nogil: - """Ensure the stream's context handle is populated.""" +cdef inline bint Stream_is_default_token(Stream self) noexcept nogil: + """Return True for CU_STREAM_LEGACY and CU_STREAM_PER_THREAD. + + These tokens carry no context of their own; they refer to whatever context + is current, so nothing resolved from one may be cached on the object. + """ + cdef uintptr_t h = as_cu(self._h_stream) + return h == cydriver.CU_STREAM_LEGACY or h == cydriver.CU_STREAM_PER_THREAD + + +cdef inline int Stream_get_ctx(Stream self, ContextHandle* h_context) except?-1 nogil: + """Resolve the stream's context handle into ``h_context``.""" cdef cydriver.CUcontext ctx - if not self._h_context: - self._h_context = get_stream_context(self._h_stream) - if self._h_context: + cdef bint is_default = Stream_is_default_token(self) + + # Default-stream tokens must never reuse a sticky object field, even if + # something else populated ``_h_context`` (defense in depth for #2485). + if self._h_context and not is_default: + h_context[0] = self._h_context return 0 - HANDLE_RETURN(cydriver.cuStreamGetCtx(as_cu(self._h_stream), &ctx)) - if ctx != NULL: - with gil: - self._h_context = create_context_handle_ref(ctx) + + h_context[0] = get_stream_context(self._h_stream) + if not h_context[0]: + HANDLE_RETURN(cydriver.cuStreamGetCtx(as_cu(self._h_stream), &ctx)) + if ctx != NULL: + with gil: + h_context[0] = create_context_handle_ref(ctx) + + if h_context[0] and not is_default: + self._h_context = h_context[0] return 0 -cdef inline int Stream_ensure_ctx_device(Stream self) except?-1: - """Ensure the stream's context and device_id are populated.""" +cdef inline int Stream_get_ctx_device(Stream self, ContextHandle* h_context, int* device_id) except?-1: + """Resolve the stream's context handle and device ID.""" cdef cydriver.CUcontext ctx cdef cydriver.CUdevice target_dev cdef ContextHandle current_context cdef bint switch_context + cdef bint is_default = Stream_is_default_token(self) - if self._device_id < 0: - with nogil: + with nogil: + Stream_get_ctx(self, h_context) + if self._device_id >= 0 and not is_default: + device_id[0] = self._device_id + else: # Get device ID from context, switching context temporarily if needed - Stream_ensure_ctx(self) current_context = get_current_context() - switch_context = (as_cu(current_context) != as_cu(self._h_context)) + switch_context = (as_cu(current_context) != as_cu(h_context[0])) if switch_context: - HANDLE_RETURN(cydriver.cuCtxPushCurrent(as_cu(self._h_context))) + HANDLE_RETURN(cydriver.cuCtxPushCurrent(as_cu(h_context[0]))) HANDLE_RETURN(cydriver.cuCtxGetDevice(&target_dev)) if switch_context: HANDLE_RETURN(cydriver.cuCtxPopCurrent(&ctx)) - self._device_id = target_dev + device_id[0] = target_dev + if not is_default: + self._device_id = device_id[0] return 0 diff --git a/cuda_core/docs/source/release/1.2.0-notes.rst b/cuda_core/docs/source/release/1.2.0-notes.rst index cf884ed64cc..4622d837c35 100644 --- a/cuda_core/docs/source/release/1.2.0-notes.rst +++ b/cuda_core/docs/source/release/1.2.0-notes.rst @@ -25,6 +25,16 @@ Fixes and enhancements versions 12.2 or newer. (`#2352 `__) +<<<<<<< HEAD +- The default-stream singletons ``LEGACY_DEFAULT_STREAM`` and + ``PER_THREAD_DEFAULT_STREAM`` no longer cache the first context and device + they observe. A default-stream token refers to whatever context is current, + so ``Stream.context``, ``Stream.device``, ``Stream.resources``, and + ``Stream.record()`` now resolve against the current context on every call. + Previously the first query pinned the singleton to one context for the + lifetime of the process, which also kept that context alive. + (`#2485 `__) +======= - :meth:`Linker.which_backend` and constructing a :class:`Linker` no longer raise ``FunctionNotFoundError`` when an nvJitLink older than 12.3 (12.0–12.2) is installed. These versions do not export the unversioned @@ -33,6 +43,7 @@ Fixes and enhancements (``cuLink``) backend, restoring the pre-0.7.0 behavior. (`#2409 `__, closes `#2408 `__) +>>>>>>> origin/main Deprecation Notices ------------------- diff --git a/cuda_core/tests/test_stream.py b/cuda_core/tests/test_stream.py index 39717861c51..55f34bbc9ec 100644 --- a/cuda_core/tests/test_stream.py +++ b/cuda_core/tests/test_stream.py @@ -405,3 +405,67 @@ def test_default_stream_per_thread_when_env_set(monkeypatch): assert default_stream() is PER_THREAD_DEFAULT_STREAM monkeypatch.delenv("CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM", raising=False) assert default_stream() is LEGACY_DEFAULT_STREAM + + +def _skip_unless_multi_gpu(): + from cuda.core import system + + if system.get_num_devices() < 2: + pytest.skip("requires 2+ GPUs") + + +@pytest.mark.agent_authored(model="claude-opus-5") +@pytest.mark.parametrize("stream", [LEGACY_DEFAULT_STREAM, PER_THREAD_DEFAULT_STREAM]) +def test_default_stream_follows_current_context(stream): + """A default-stream token denotes whatever context is current, so its + queries follow a context switch instead of reporting the first context + they ever saw (issue #2485).""" + _skip_unless_multi_gpu() + + for device_id in (0, 1, 0): + dev = Device(device_id) + dev.set_current() + assert stream.device.device_id == device_id + assert stream.context == dev.context + assert stream.record().context == dev.context + # Exercise Stream.resources and check it tracks the same context + # resolution as .context (issue #2485). + assert stream.resources.sm.sm_count == stream.context.resources.sm.sm_count + assert stream.resources.sm.sm_count == dev.resources.sm.sm_count + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_default_stream_first_touch_does_not_pin_context(): + """Any query resolves the context, including repr(), so logging a default + stream must not bind the singleton to whichever context happened to be + current at the time (issue #2485).""" + _skip_unless_multi_gpu() + + Device(1).set_current() + repr(LEGACY_DEFAULT_STREAM) + + dev0 = Device(0) + dev0.set_current() + assert LEGACY_DEFAULT_STREAM.device.device_id == 0 + assert LEGACY_DEFAULT_STREAM.context == dev0.context + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_created_stream_keeps_its_own_context(): + """A created stream has a context fixed at creation and keeps reporting it + across a switch; only default-stream tokens follow the current context + (issue #2485).""" + _skip_unless_multi_gpu() + + dev0 = Device(0) + dev0.set_current() + stream = dev0.create_stream() + assert stream.context == dev0.context + + try: + Device(1).set_current() + assert stream.device.device_id == 0 + assert stream.context == dev0.context + finally: + dev0.set_current() + stream.close() From 7e7d3c14fc4ce848b58a8bf39c90ca1db89ce014 Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Wed, 5 Aug 2026 21:01:14 -0700 Subject: [PATCH 29/50] build: report internal build dependency provenance (#2509) --- cuda_bindings/build_hooks.py | 12 +++++++++--- cuda_core/build_hooks.py | 12 +++++++++--- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/cuda_bindings/build_hooks.py b/cuda_bindings/build_hooks.py index a50133f9777..99ad5c66268 100644 --- a/cuda_bindings/build_hooks.py +++ b/cuda_bindings/build_hooks.py @@ -16,6 +16,7 @@ import sys import sysconfig import tempfile +from pathlib import Path from warnings import warn from setuptools import build_meta as _build_meta @@ -50,9 +51,9 @@ def _import_get_cuda_path_or_home(): cuda = None for p in sys.path: - sp_cuda = os.path.join(p, "cuda") - if os.path.isdir(os.path.join(sp_cuda, "pathfinder")): - cuda.__path__ = list(cuda.__path__) + [sp_cuda] + sp_cuda = Path(p) / "cuda" + if (sp_cuda / "pathfinder").is_dir(): + cuda.__path__ = list(cuda.__path__) + [str(sp_cuda)] break else: raise ModuleNotFoundError( @@ -61,6 +62,11 @@ def _import_get_cuda_path_or_home(): ) import cuda.pathfinder + pathfinder_dir = Path(cuda.pathfinder.__file__).parent + print( + f"Using cuda-pathfinder {cuda.pathfinder.__version__} from {pathfinder_dir}", + file=sys.stderr, + ) return cuda.pathfinder.get_cuda_path_or_home diff --git a/cuda_core/build_hooks.py b/cuda_core/build_hooks.py index 4aec4981c53..05cc9267726 100644 --- a/cuda_core/build_hooks.py +++ b/cuda_core/build_hooks.py @@ -46,9 +46,9 @@ def _import_get_cuda_path_or_home(): cuda = None for p in sys.path: - sp_cuda = os.path.join(p, "cuda") - if os.path.isdir(os.path.join(sp_cuda, "pathfinder")): - cuda.__path__ = list(cuda.__path__) + [sp_cuda] + sp_cuda = Path(p) / "cuda" + if (sp_cuda / "pathfinder").is_dir(): + cuda.__path__ = list(cuda.__path__) + [str(sp_cuda)] break else: raise ModuleNotFoundError( @@ -57,6 +57,11 @@ def _import_get_cuda_path_or_home(): ) import cuda.pathfinder + pathfinder_dir = Path(cuda.pathfinder.__file__).parent + print( + f"Using cuda-pathfinder {cuda.pathfinder.__version__} from {pathfinder_dir}", + file=sys.stderr, + ) return cuda.pathfinder.get_cuda_path_or_home @@ -136,6 +141,7 @@ def _build_cuda_core(debug=False): import cuda.bindings bindings_path = Path(cuda.bindings.__file__).parent # .../cuda/bindings/ + print(f"Using cuda-bindings {cuda.bindings.__version__} from {bindings_path}", file=sys.stderr) cuda_package_dir = bindings_path.parent.parent # .../cuda_bindings/ (contains cuda/) if str(cuda_package_dir) not in sys.path: sys.path.insert(0, str(cuda_package_dir)) From 979b65fb2d9b59cc75f6298297b37e35cd1eef17 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Thu, 6 Aug 2026 00:29:04 -0400 Subject: [PATCH 30/50] Fix nvbug6550424: Don't check NVML init behavior on CTK >= 13.4 (#2512) --- cuda_bindings/tests/nvml/test_init.py | 2 + cuda_bindings/tests/test_cuda.py | 49 +++++++++---------- cuda_bindings/tests/test_cudart.py | 43 +++++++--------- .../cuda_python_test_helpers/__init__.py | 10 ++++ 4 files changed, 53 insertions(+), 51 deletions(-) diff --git a/cuda_bindings/tests/nvml/test_init.py b/cuda_bindings/tests/nvml/test_init.py index a47af24dc6a..c56c400a0b9 100644 --- a/cuda_bindings/tests/nvml/test_init.py +++ b/cuda_bindings/tests/nvml/test_init.py @@ -7,6 +7,7 @@ import pytest from cuda.bindings import nvml +from cuda_python_test_helpers import driver_version_less_than def assert_nvml_is_initialized(): @@ -43,6 +44,7 @@ def get_architecture_name(arch): @pytest.mark.skipif(sys.platform == "win32", reason="Test not supported on Windows") @pytest.mark.thread_unsafe(reason="nvml init affects other threads") +@pytest.mark.skipif(not driver_version_less_than(13040), reason="Init behavior changed in CUDA 13.4") def test_init_ref_count(): """ Verifies that we can call NVML shutdown and init(2) multiple times, and that ref counting works diff --git a/cuda_bindings/tests/test_cuda.py b/cuda_bindings/tests/test_cuda.py index e2751df9237..7bef2b844aa 100644 --- a/cuda_bindings/tests/test_cuda.py +++ b/cuda_bindings/tests/test_cuda.py @@ -15,14 +15,7 @@ import cuda.bindings.driver as cuda import cuda.bindings.runtime as cudart from cuda.bindings import driver - - -def driverVersionLessThan(target): - (err,) = cuda.cuInit(0) - assert err == cuda.CUresult.CUDA_SUCCESS - err, version = cuda.cuDriverGetVersion() - assert err == cuda.CUresult.CUDA_SUCCESS - return version < target +from cuda_python_test_helpers import driver_version_less_than def supportsMemoryPool(): @@ -265,7 +258,7 @@ def test_cuda_CUstreamBatchMemOpParams(): @pytest.mark.skipif( - driverVersionLessThan(11030) or not supportsMemoryPool(), reason="When new attributes were introduced" + driver_version_less_than(11030) or not supportsMemoryPool(), reason="When new attributes were introduced" ) def test_cuda_memPool_attr(): poolProps = cuda.CUmemPoolProps() @@ -328,7 +321,7 @@ def test_cuda_memPool_attr(): @pytest.mark.skipif( - driverVersionLessThan(11030) or not supportsManagedMemory(), reason="When new attributes were introduced" + driver_version_less_than(11030) or not supportsManagedMemory(), reason="When new attributes were introduced" ) def test_cuda_pointer_attr(): err, ptr = cuda.cuMemAllocManaged(0x1000, cuda.CUmemAttach_flags.CU_MEM_ATTACH_GLOBAL.value) @@ -379,7 +372,7 @@ def test_cuda_pointer_attr(): @pytest.mark.skipif( - driverVersionLessThan(11030) or not supportsManagedMemory(), reason="When new attributes were introduced" + driver_version_less_than(11030) or not supportsManagedMemory(), reason="When new attributes were introduced" ) def test_pointer_get_attributes_device_ordinal(): attributes = [ @@ -457,7 +450,9 @@ def test_cuda_mem_range_attr(device): assert err == cuda.CUresult.CUDA_SUCCESS -@pytest.mark.skipif(driverVersionLessThan(11040) or not supportsMemoryPool(), reason="Mempool for graphs not supported") +@pytest.mark.skipif( + driver_version_less_than(11040) or not supportsMemoryPool(), reason="Mempool for graphs not supported" +) @pytest.mark.thread_unsafe(reason="used high memory can be higher if threaded.") def test_cuda_graphMem_attr(device): err, stream = cuda.cuStreamCreate(0) @@ -516,7 +511,7 @@ def test_cuda_graphMem_attr(device): @pytest.mark.skipif( - driverVersionLessThan(12010) + driver_version_less_than(12010) or not supportsCudaAPI("cuCoredumpSetAttributeGlobal") or not supportsCudaAPI("cuCoredumpGetAttributeGlobal"), reason="Coredump API not present", @@ -566,7 +561,7 @@ def test_get_error_name_and_string(): # TODO: cuStreamGetCaptureInfo_v2 -@pytest.mark.skipif(driverVersionLessThan(11030), reason="Driver too old for cuStreamGetCaptureInfo_v2") +@pytest.mark.skipif(driver_version_less_than(11030), reason="Driver too old for cuStreamGetCaptureInfo_v2") def test_stream_capture(): pass @@ -636,7 +631,7 @@ def test_invalid_repr_attribute(): @pytest.mark.skipif( - driverVersionLessThan(12020) + driver_version_less_than(12020) or not supportsCudaAPI("cuGraphAddNode") or not supportsCudaAPI("cuGraphNodeSetParams") or not supportsCudaAPI("cuGraphExecNodeSetParams"), @@ -748,7 +743,7 @@ def test_graph_poly(): @pytest.mark.skipif( - driverVersionLessThan(12040) or not supportsCudaAPI("cuDeviceGetDevResource"), + driver_version_less_than(12040) or not supportsCudaAPI("cuDeviceGetDevResource"), reason="Polymorphic graph APIs required", ) def test_cuDeviceGetDevResource(device): @@ -768,7 +763,7 @@ def test_cuDeviceGetDevResource(device): @pytest.mark.skipif( - driverVersionLessThan(12030) or not supportsCudaAPI("cuGraphConditionalHandleCreate"), + driver_version_less_than(12030) or not supportsCudaAPI("cuGraphConditionalHandleCreate"), reason="Conditional graph APIs required", ) def test_conditional(ctx): @@ -830,14 +825,14 @@ def test_all_CUresult_codes(): assert num_good >= 76 # CTK 11.0.3_450.51.06 -@pytest.mark.skipif(driverVersionLessThan(12030), reason="Driver too old for cuKernelGetName") +@pytest.mark.skipif(driver_version_less_than(12030), reason="Driver too old for cuKernelGetName") def test_cuKernelGetName_failure(): err, name = cuda.cuKernelGetName(0) assert err == cuda.CUresult.CUDA_ERROR_INVALID_VALUE assert name is None -@pytest.mark.skipif(driverVersionLessThan(12030), reason="Driver too old for cuFuncGetName") +@pytest.mark.skipif(driver_version_less_than(12030), reason="Driver too old for cuFuncGetName") def test_cuFuncGetName_failure(): err, name = cuda.cuFuncGetName(0) assert err == cuda.CUresult.CUDA_ERROR_INVALID_VALUE @@ -845,7 +840,7 @@ def test_cuFuncGetName_failure(): @pytest.mark.skipif( - driverVersionLessThan(12080) or not supportsCudaAPI("cuCheckpointProcessGetState"), + driver_version_less_than(12080) or not supportsCudaAPI("cuCheckpointProcessGetState"), reason="When API was introduced", ) def test_cuCheckpointProcessGetState_failure(): @@ -887,7 +882,7 @@ def test_struct_pointer_comparison(target): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cuGraphGetId"), + driver_version_less_than(13010) or not supportsCudaAPI("cuGraphGetId"), reason="Requires CUDA 13.1+", ) def test_cuGraphGetId(device, ctx): @@ -914,7 +909,7 @@ def test_cuGraphGetId(device, ctx): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cuGraphExecGetId"), + driver_version_less_than(13010) or not supportsCudaAPI("cuGraphExecGetId"), reason="Requires CUDA 13.1+", ) def test_cuGraphExecGetId(device, ctx): @@ -1040,7 +1035,7 @@ def test_cuGraphNodeGetDependencies_edgeData_outlives_call(device, ctx): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cuGraphNodeGetLocalId"), + driver_version_less_than(13010) or not supportsCudaAPI("cuGraphNodeGetLocalId"), reason="Requires CUDA 13.1+", ) def test_cuGraphNodeGetLocalId(device, ctx): @@ -1082,7 +1077,7 @@ def test_cuGraphNodeGetLocalId(device, ctx): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cuGraphNodeGetToolsId"), + driver_version_less_than(13010) or not supportsCudaAPI("cuGraphNodeGetToolsId"), reason="Requires CUDA 13.1+", ) def test_cuGraphNodeGetToolsId(device, ctx): @@ -1111,7 +1106,7 @@ def test_cuGraphNodeGetToolsId(device, ctx): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cuGraphNodeGetContainingGraph"), + driver_version_less_than(13010) or not supportsCudaAPI("cuGraphNodeGetContainingGraph"), reason="Requires CUDA 13.1+", ) def test_cuGraphNodeGetContainingGraph(device, ctx): @@ -1158,7 +1153,7 @@ def test_cuGraphNodeGetContainingGraph(device, ctx): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cuStreamGetDevResource"), + driver_version_less_than(13010) or not supportsCudaAPI("cuStreamGetDevResource"), reason="Requires CUDA 13.1+", ) def test_cuStreamGetDevResource(device, ctx): @@ -1177,7 +1172,7 @@ def test_cuStreamGetDevResource(device, ctx): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cuDevSmResourceSplit"), + driver_version_less_than(13010) or not supportsCudaAPI("cuDevSmResourceSplit"), reason="Requires CUDA 13.1+", ) def test_cuDevSmResourceSplit(device, ctx): diff --git a/cuda_bindings/tests/test_cudart.py b/cuda_bindings/tests/test_cudart.py index 0a4e2b8bb82..7b70acdeb46 100644 --- a/cuda_bindings/tests/test_cudart.py +++ b/cuda_bindings/tests/test_cudart.py @@ -12,6 +12,7 @@ import cuda.bindings.runtime as cudart from cuda import pathfinder from cuda.bindings import runtime +from cuda_python_test_helpers import driver_version_less_than def isSuccess(err): @@ -22,12 +23,6 @@ def assertSuccess(err): assert isSuccess(err) -def driverVersionLessThan(target): - err, version = cudart.cudaDriverGetVersion() - assertSuccess(err) - return version < target - - def supportsMemoryPool(): err, isSupported = cudart.cudaDeviceGetAttribute(cudart.cudaDeviceAttr.cudaDevAttrMemoryPoolsSupported, 0) return isSuccess(err) and isSupported @@ -504,7 +499,7 @@ def test_cudart_cudaGetDeviceProperties(): @pytest.mark.skipif( - driverVersionLessThan(11030) or not supportsMemoryPool(), reason="When new attributes were introduced" + driver_version_less_than(11030) or not supportsMemoryPool(), reason="When new attributes were introduced" ) def test_cudart_MemPool_attr(): poolProps = cudart.cudaMemPoolProps() @@ -1445,7 +1440,7 @@ def test_cudart_func_callback(): @pytest.mark.skipif( - driverVersionLessThan(12030) or not supportsCudaAPI("cudaGraphConditionalHandleCreate"), + driver_version_less_than(12030) or not supportsCudaAPI("cudaGraphConditionalHandleCreate"), reason="Conditional graph APIs required", ) def test_cudart_conditional(): @@ -1503,7 +1498,7 @@ def test_getLocalRuntimeVersion(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaGraphGetId"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaGraphGetId"), reason="Requires CUDA 13.1+", ) def test_cudaGraphGetId(): @@ -1530,7 +1525,7 @@ def test_cudaGraphGetId(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaGraphExecGetId"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaGraphExecGetId"), reason="Requires CUDA 13.1+", ) def test_cudaGraphExecGetId(): @@ -1577,7 +1572,7 @@ def test_cudaGraphExecGetId(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaGraphNodeGetLocalId"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaGraphNodeGetLocalId"), reason="Requires CUDA 13.1+", ) def test_cudaGraphNodeGetLocalId(): @@ -1619,7 +1614,7 @@ def test_cudaGraphNodeGetLocalId(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaGraphNodeGetToolsId"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaGraphNodeGetToolsId"), reason="Requires CUDA 13.1+", ) def test_cudaGraphNodeGetToolsId(): @@ -1648,7 +1643,7 @@ def test_cudaGraphNodeGetToolsId(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaGraphNodeGetContainingGraph"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaGraphNodeGetContainingGraph"), reason="Requires CUDA 13.1+", ) def test_cudaGraphNodeGetContainingGraph(): @@ -1695,7 +1690,7 @@ def test_cudaGraphNodeGetContainingGraph(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaStreamGetDevResource"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaStreamGetDevResource"), reason="Requires CUDA 13.1+", ) def test_cudaStreamGetDevResource(): @@ -1714,7 +1709,7 @@ def test_cudaStreamGetDevResource(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaDeviceGetDevResource"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaDeviceGetDevResource"), reason="Requires CUDA 13.1+", ) def test_cudaDeviceGetDevResource(): @@ -1729,7 +1724,7 @@ def test_cudaDeviceGetDevResource(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaDeviceGetExecutionCtx"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaDeviceGetExecutionCtx"), reason="Requires CUDA 13.1+", ) def test_cudaExecutionCtxGetDevResource(): @@ -1747,7 +1742,7 @@ def test_cudaExecutionCtxGetDevResource(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaDeviceGetExecutionCtx"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaDeviceGetExecutionCtx"), reason="Requires CUDA 13.1+", ) def test_cudaExecutionCtxGetDevice(): @@ -1767,7 +1762,7 @@ def test_cudaExecutionCtxGetDevice(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaDeviceGetExecutionCtx"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaDeviceGetExecutionCtx"), reason="Requires CUDA 13.1+", ) def test_cudaExecutionCtxGetId(): @@ -1795,7 +1790,7 @@ def test_cudaExecutionCtxGetId(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaDevSmResourceSplit"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaDevSmResourceSplit"), reason="Requires CUDA 13.1+", ) def test_cudaDevSmResourceSplit(): @@ -1864,7 +1859,7 @@ def test_cudaDevSmResourceSplit(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaDevSmResourceSplitByCount"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaDevSmResourceSplitByCount"), reason="Requires CUDA 13.1+", ) def test_cudaDevSmResourceSplitByCount(): @@ -1887,7 +1882,7 @@ def test_cudaDevSmResourceSplitByCount(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaDevResourceGenerateDesc"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaDevResourceGenerateDesc"), reason="Requires CUDA 13.1+", ) def test_cudaDevResourceGenerateDesc(): @@ -1904,7 +1899,7 @@ def test_cudaDevResourceGenerateDesc(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaGreenCtxCreate"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaGreenCtxCreate"), reason="Requires CUDA 13.1+", ) def test_cudaGreenCtxCreate(): @@ -1935,7 +1930,7 @@ def test_cudaGreenCtxCreate(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaExecutionCtxStreamCreate"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaExecutionCtxStreamCreate"), reason="Requires CUDA 13.1+", ) def test_cudaExecutionCtxStreamCreate(): @@ -1956,7 +1951,7 @@ def test_cudaExecutionCtxStreamCreate(): @pytest.mark.skipif( - driverVersionLessThan(13010) or not supportsCudaAPI("cudaGraphConditionalHandleCreate_v2"), + driver_version_less_than(13010) or not supportsCudaAPI("cudaGraphConditionalHandleCreate_v2"), reason="Requires CUDA 13.1+", ) def test_cudaGraphConditionalHandleCreate_v2(): diff --git a/cuda_python_test_helpers/cuda_python_test_helpers/__init__.py b/cuda_python_test_helpers/cuda_python_test_helpers/__init__.py index c67162483f5..7e1e33a428b 100644 --- a/cuda_python_test_helpers/cuda_python_test_helpers/__init__.py +++ b/cuda_python_test_helpers/cuda_python_test_helpers/__init__.py @@ -65,3 +65,13 @@ def under_compute_sanitizer() -> bool: # Another common indicator: sanitizer injectors are configured via env vars. inj = os.environ.get("CUDA_INJECTION64_PATH", "") return "compute-sanitizer" in inj or "cuda-memcheck" in inj + + +def driver_version_less_than(target): + from cuda.bindings import driver + + (err,) = driver.cuInit(0) + assert err == driver.CUresult.CUDA_SUCCESS + err, version = driver.cuDriverGetVersion() + assert err == driver.CUresult.CUDA_SUCCESS + return version < target From 1656fb779603f904824f488c23f423969e2df676 Mon Sep 17 00:00:00 2001 From: Andy Jost Date: Thu, 6 Aug 2026 07:54:31 -0700 Subject: [PATCH 31/50] cuda.core: add executable graph node updates (#2473) * Add executable graph attachment ownership Install a private CUDA user object per graph executable so later node updates can retain replacement resources safely. * Add executable graph node updates Expose ephemeral graph-node views that update complete executable parameters while retaining every replacement resource CUDA may still use. * test(core): cover executable graph node updates Exercise public mutators, rollback, source reclamation, independent ownership, whole updates, and in-flight cleanup end to end. * refactor(core): own exec graph creation behind one handle function Instantiation and whole-graph update each went through a prepare/commit pair. That exposed an opaque transaction type over the internal C++ interface and split the exec ownership contract between C++ and Cython, unlike every other resource handle, which a single create_* function owns end to end. Replace the pairs with create_graph_exec_handle and graph_exec_update. Each stages a fresh attachment accumulator on the source graph, makes the CUDA call with the GIL released, and adopts or publishes the result, so the staging transaction becomes a stack guard in the anonymous namespace instead of a header type. Cython keeps only what belongs to it: filling the instantiation params and decoding the failure reasons. The two driver entry points move into the C++ loader table with the calls. Convert the attachment append transaction to the unique_ptr plus rollback deleter pattern that node attachments already use, which retires the committed flag in favor of the same release-and-delete mechanism. Drop GraphExecBox::attachment_object, which nothing reads. * test(core): cover executable attachment accumulator lifetimes Three gaps remained around owners attached to an executable graph. Sequential updates to the same node must keep the superseded owner reachable, because CUDA cannot detach user objects from an executable; verified by breaking the append into a replace, which fails the new test on exactly that assertion. Closing an executable while a launch is in flight must not retire the accumulator, since the launch still writes through the buffer that an individual node update attached. A child-graph update attaches no owner of its own and relies on CUDA cloning the replacement graph's user object references into the executable. Assert that contract directly: the callback outlives the definition that supplied it and is released with the executable. * docs(core): describe the executable attachment accumulator CUDA accepts user objects on a CUgraph only, so an executable graph can never receive an owner after it exists. Document the consequence: one accumulator is retained on the source graph, propagated by instantiation or whole-graph update, and then released from the source so the executable becomes its only owner. Record why an owner is never removed once appended, and correct the two Scope entries that still described executable graphs as untracked. State the retention limit in the release notes as well. The API reference already documents it, but the note is what a reader sees when adopting the feature, and retention that looks unbounded deserves the warning there. * docs(core): focus executable attachment docs on cuda.core behavior Describe retention and complete-replacement rules without framing the notes around CUDA limitations, and shorten the executable attachment design section to problem, solution, and append-vs-replace limits. * docs(core): clarify Graph.__getitem__ for executable node updates Describe how callers use the view rather than how the binding retains handles or when CUDA validates the node association. * Address review feedback on executable graph attachments Clarify attachment ownership and deferred-cleanup docs, trim the invariants list to the cross-cutting rules, initialize instantiate params with Cython struct syntax, and simplify the executable update test helper. * test(core): restore explicit executable update kwargs The shared replacement fixture carries extra fields that are not update parameters, so spreading it as kwargs breaks memset and kernel cases. --- cuda_core/cuda/core/_cpp/GRAPH_ATTACHMENTS.md | 76 ++- cuda_core/cuda/core/_cpp/resource_handles.cpp | 270 +++++++++- cuda_core/cuda/core/_cpp/resource_handles.hpp | 53 +- cuda_core/cuda/core/_resource_handles.pxd | 23 +- cuda_core/cuda/core/_resource_handles.pyi | 3 +- cuda_core/cuda/core/_resource_handles.pyx | 21 +- cuda_core/cuda/core/_utils/_weak_handles.pyi | 5 +- cuda_core/cuda/core/_utils/_weak_handles.pyx | 17 +- cuda_core/cuda/core/graph/__init__.pxd | 8 + cuda_core/cuda/core/graph/_graph_builder.pxd | 2 +- cuda_core/cuda/core/graph/_graph_builder.pyi | 13 +- cuda_core/cuda/core/graph/_graph_builder.pyx | 73 ++- .../cuda/core/graph/_graph_definition.pyx | 3 +- cuda_core/cuda/core/graph/_subclasses.pxd | 46 +- cuda_core/cuda/core/graph/_subclasses.pyi | 99 +++- cuda_core/cuda/core/graph/_subclasses.pyx | 371 ++++++++++++++ cuda_core/docs/source/api.rst | 35 ++ cuda_core/docs/source/release/1.2.0-notes.rst | 14 +- .../tests/graph/test_graph_node_update.py | 480 +++++++++++++++++- 19 files changed, 1532 insertions(+), 80 deletions(-) diff --git a/cuda_core/cuda/core/_cpp/GRAPH_ATTACHMENTS.md b/cuda_core/cuda/core/_cpp/GRAPH_ATTACHMENTS.md index 89003ae0b7f..fdaf77785b2 100644 --- a/cuda_core/cuda/core/_cpp/GRAPH_ATTACHMENTS.md +++ b/cuda_core/cuda/core/_cpp/GRAPH_ATTACHMENTS.md @@ -77,12 +77,13 @@ The CUDA user-object reference count controls the attachment lifetime. `GraphAttachmentMap` only lets cuda.core find the attachment currently associated with a node. -Each `NodeAttachment` contains two type-erased `OpaqueHandle` owners: +Each `NodeAttachment` has two type-erased `OpaqueHandle` slots, allowing it to +hold up to two node-specific resource owners. These are: -- kernel: kernel and argument storage -- host callback: callback and copied user data -- memcpy: destination and source -- memset or event: destination or event in the first owner +- kernel node: kernel and argument storage +- host callback node: callback and copied user data +- memcpy node: destination and source +- memset or event node: destination or event `OpaqueHandle` is `shared_ptr`. Existing cuda.core handles reuse their shared ownership when converted to it. Python objects and copied callback @@ -93,23 +94,47 @@ published attachment. The resources those owners keep alive, including Python objects, may remain mutable, but they must not be modified in a way that releases resources still referenced by an installed parameter version. +## Executable graph attachments + +Executable graphs can be modified after instantiation. Those updates may +introduce new resources (events, memory, kernels, kernel parameters, and host +callbacks) that must outlive in-flight launches. CUDA provides no way to attach +user objects to an executable graph (`cuGraphRetainUserObject` accepts a +`CUgraph` only), so cuda.core emulates that lifetime tracking. + +Before instantiation or whole-graph update, cuda.core retains one +`ExecAttachments` accumulator on the source graph as a CUDA user object. +Instantiation or `cuGraphExecUpdate` propagates that reference into the +executable; cuda.core then releases the source graph's temporary reference so +the executable (and its in-flight launches) own the accumulator. Individual +node updates append owners to that accumulator through the same prepare/commit +transaction used for definition attachments. + +Appended owners are never removed: each update can only grow the accumulator. +A successful whole-graph update replaces the accumulator entirely, so the +previous owners are dropped once their last launch finishes. Enable/disable +attaches nothing. A child-graph update relies on CUDA cloning the replacement +graph's user-object references, which carry the child definition's attachments. + ## Deferred cleanup CUDA invokes a user-object destructor on an internal thread where CUDA API calls are forbidden. Destroying an attachment there could release handles whose deleters call CUDA or run Python finalizers. -`NodeAttachment` therefore inherits from `DeferredCleanupItem`. The CUDA +`NodeAttachment` and `ExecAttachments` therefore inherit from +`DeferredCleanupItem`. The CUDA destructor callback only adds the attachment to the process-lifetime `DeferredCleanupQueue` and requests a `Py_AddPendingCall`. One pending call drains all queued attachments from Python's main thread. The -queue coalesces work because CPython's pending-call queue is bounded. If -scheduling fails, attachments stay queued and a later enqueue or safe cuda.core -entry retries. Graph and executable-graph destruction and explicit close paths -provide additional retry points. During Python finalization, scheduling stops -and unreclaimable attachments are intentionally leaked rather than destroyed -in an unsafe context. +queue coalesces work because CPython's pending-call queue is bounded, and there +could be many more deferred cleanup items than allowed pending calls. If +`Py_AddPendingCall` fails, the attachments remain queued. A later successful +`Py_AddPendingCall` will safely clean them up. Graph and executable-graph +destruction and explicit close paths provide additional retry points. During +Python finalization, scheduling stops and unreclaimable attachments are +intentionally leaked rather than destroyed in an unsafe context. ## Graph hierarchy state @@ -157,19 +182,15 @@ be invalidated when CUDA destroys that graph. They use separate ## Invariants -1. The owner bundle of a published `NodeAttachment` is never modified in place. +1. The owner bundle of a published `NodeAttachment` is never modified in place; + replace the whole bundle. 2. CUDA user-object references, not metadata pointers, own attachments. -3. Metadata is removed or replaced before its graph reference is released. -4. Fallible attachment setup and metadata allocation happen before the CUDA - graph mutation they support. -5. Every live cuda.core `CUgraph` has one canonical `GraphBox` and registry - entry. -6. Graph boxes remain in parent-before-child order. -7. Destroyed child boxes remain at stable addresses in the graveyard. -8. A raw graph handle is unregistered before its box becomes a tombstone. -9. CUDA callbacks only enqueue attachments; they never release owners or call +3. Fallible attachment setup and metadata allocation happen before the CUDA + graph mutation they support; metadata is removed or replaced before its + graph reference is released. +4. CUDA callbacks only enqueue attachments; they never release owners or call CUDA. -10. Graph mutations and their metadata updates require the same external +5. Graph mutations and their metadata updates require the same external synchronization as the underlying CUDA graph. ## Scope @@ -177,10 +198,11 @@ be invalidated when CUDA destroys that graph. They use separate - Attachment metadata tracks graph mutations performed through cuda.core. - Raw driver clones receive the CUDA user-object references needed for safe execution, but cuda.core cannot reconstruct their node-to-attachment map. -- Executable graphs rely on CUDA's inherited user-object references; they do - not use `GraphAttachmentMap`. -- Direct executable-node updates require separate executable ownership and are - not tracked by definition attachment metadata. +- Executable graphs keep one append-only accumulator instead of a + `GraphAttachmentMap`. cuda.core cannot map an executable node back to its + owners, so it can neither report nor release them individually. +- Executable-node updates do not change definition attachment metadata, and + definition updates do not change an executable's accumulator. - Stream capture explicitly retains host callbacks. Other captured operations keep their documented caller-owned lifetime contract. - CPython's cyclic garbage collector cannot follow the ownership path from a diff --git a/cuda_core/cuda/core/_cpp/resource_handles.cpp b/cuda_core/cuda/core/_cpp/resource_handles.cpp index 2102d36f22f..ef1b8d0f2f8 100644 --- a/cuda_core/cuda/core/_cpp/resource_handles.cpp +++ b/cuda_core/cuda/core/_cpp/resource_handles.cpp @@ -74,6 +74,8 @@ decltype(&cuLibraryGetKernel) p_cuLibraryGetKernel = nullptr; // Graph decltype(&cuGraphDestroy) p_cuGraphDestroy = nullptr; +decltype(&cuGraphInstantiateWithParams) p_cuGraphInstantiateWithParams = nullptr; +decltype(&cuGraphExecUpdate) p_cuGraphExecUpdate = nullptr; decltype(&cuGraphExecDestroy) p_cuGraphExecDestroy = nullptr; decltype(&cuUserObjectCreate) p_cuUserObjectCreate = nullptr; decltype(&cuUserObjectRelease) p_cuUserObjectRelease = nullptr; @@ -1913,26 +1915,274 @@ CUresult graph_clone_attachments( // ============================================================================ namespace { + +// Append-only owners introduced by individual executable-node updates. CUDA +// owns this payload through a user object propagated into the CUgraphExec. +struct ExecAttachments : DeferredCleanupItem { + CUuserObject object = nullptr; + std::vector owners; +}; + struct GraphExecBox { - CUgraphExec resource; + CUgraphExec resource = nullptr; + ExecAttachments* attachments = nullptr; // Non-owning. + + ~GraphExecBox() noexcept { + if (resource) { + GILReleaseGuard gil; + p_cuGraphExecDestroy(resource); + } + // The accumulator fields may be dangling after exec destruction. + retry_deferred_cleanup(); + } }; -} // namespace -GraphExecHandle create_graph_exec_handle(CUgraphExec graph_exec) { - auto box = std::shared_ptr( - new GraphExecBox{graph_exec}, - [](const GraphExecBox* b) { - { +GraphExecBox* get_exec_box(const GraphExecHandle& h) noexcept { + return const_cast( + reinterpret_cast(h.get())); +} + +GraphExecHandle make_graph_exec_handle( + CUgraphExec graph_exec, ExecAttachments* attachments) { + struct RawGraphExecGuard { + CUgraphExec resource; + + ~RawGraphExecGuard() noexcept { + if (resource) { GILReleaseGuard gil; - p_cuGraphExecDestroy(b->resource); + p_cuGraphExecDestroy(resource); } retry_deferred_cleanup(); - delete b; } - ); + } guard{graph_exec}; + + auto box = std::make_shared(); + box->resource = graph_exec; + box->attachments = attachments; + guard.resource = nullptr; return GraphExecHandle(box, &box->resource); } +// Holds a fresh accumulator retained on the source graph across a CUDA call +// that propagates user objects into an exec. Releasing drops the source's +// reference: after successful propagation the exec keeps the accumulator +// alive, and otherwise this drops its last reference. +struct ExecAttachmentStaging { + GraphHandle h_source; + ExecAttachments* accumulator = nullptr; + + ~ExecAttachmentStaging() noexcept { + release(); + } + + CUresult release() noexcept { + if (!h_source || !accumulator) { + return CUDA_SUCCESS; + } + const CUuserObject object = accumulator->object; + const GraphHandle source = std::move(h_source); + accumulator = nullptr; + GILReleaseGuard gil; + return p_cuGraphReleaseUserObject(*source, object, 1); + } +}; + +// Create an accumulator and retain it on h_source, so that a following +// instantiation or whole-graph update propagates a reference into the exec. +CUresult stage_exec_attachments( + const GraphHandle& h_source, ExecAttachmentStaging* out_staging) { + if (!p_cuUserObjectCreate || !p_cuUserObjectRelease || + !p_cuGraphRetainUserObject || !p_cuGraphReleaseUserObject) { + return CUDA_ERROR_NOT_SUPPORTED; + } + + ensure_deferred_cleanup_ready(); + auto* accumulator = new ExecAttachments; + + CUuserObject object = nullptr; + CUresult status; + { + GILReleaseGuard gil; + status = p_cuUserObjectCreate( + &object, + static_cast(accumulator), + reinterpret_cast(enqueue_cleanup), + 1, + CU_USER_OBJECT_NO_DESTRUCTOR_SYNC); + if (status != CUDA_SUCCESS) { + delete accumulator; + return status; + } + accumulator->object = object; + status = p_cuGraphRetainUserObject( + *h_source, object, 1, CU_GRAPH_USER_OBJECT_MOVE); + if (status != CUDA_SUCCESS) { + // Dropping the last reference retires the accumulator. + p_cuUserObjectRelease(object, 1); + return status; + } + } + + out_staging->h_source = h_source; + out_staging->accumulator = accumulator; + return CUDA_SUCCESS; +} + +} // namespace + +// State held by PreparedExecAttachment between preparation and commit. It keeps +// the exec alive and remembers the accumulator size before the append, so that +// rollback can drop owners staged for a mutation that CUDA rejected. +struct PreparedExecAttachmentState { + GraphExecHandle h_exec; + ExecAttachments* attachments = nullptr; + size_t original_size = 0; + + PreparedExecAttachmentState( + GraphExecHandle h_exec_, + ExecAttachments* attachments_, + size_t original_size_) + : h_exec(std::move(h_exec_)), + attachments(attachments_), + original_size(original_size_) {} +}; + +void rollback_prepared_exec_attachment( + PreparedExecAttachmentState* state) noexcept { + if (!state) { + return; + } + if (state->attachments) { + while (state->attachments->owners.size() > state->original_size) { + state->attachments->owners.pop_back(); + } + } + delete state; +} + +GraphExecHandle create_graph_exec_handle( + const GraphHandle& h_source, + CUDA_GRAPH_INSTANTIATE_PARAMS* params) { + if (!h_source || !*h_source || !params) { + err = CUDA_ERROR_INVALID_VALUE; + return {}; + } + if (!p_cuGraphInstantiateWithParams) { + err = CUDA_ERROR_NOT_SUPPORTED; + return {}; + } + + ExecAttachmentStaging staging; + if (CUDA_SUCCESS != (err = stage_exec_attachments(h_source, &staging))) { + return {}; + } + + CUgraphExec graph_exec = nullptr; + { + GILReleaseGuard gil; + err = p_cuGraphInstantiateWithParams(&graph_exec, *h_source, params); + } + if (err != CUDA_SUCCESS) { + return {}; + } + // CUDA can report a specific failure while returning success. The exec is + // then unusable, so it stays unadopted for the caller to diagnose from + // params->result_out. + if (params->result_out != CUDA_GRAPH_INSTANTIATE_SUCCESS) { + return {}; + } + if (!graph_exec) { + err = CUDA_ERROR_INVALID_VALUE; + return {}; + } + + GraphExecHandle h_exec = make_graph_exec_handle( + graph_exec, staging.accumulator); + if (CUDA_SUCCESS != (err = staging.release())) { + return {}; + } + return h_exec; +} + +CUresult graph_exec_update( + const GraphExecHandle& h_exec, + const GraphHandle& h_source, + CUgraphExecUpdateResultInfo* result_info) { + if (!h_exec || !h_source || !*h_source || !result_info) { + return CUDA_ERROR_INVALID_VALUE; + } + if (!p_cuGraphExecUpdate) { + return CUDA_ERROR_NOT_SUPPORTED; + } + + GraphExecBox* box = get_exec_box(h_exec); + if (!box->resource) { + return CUDA_ERROR_INVALID_VALUE; + } + + ExecAttachmentStaging staging; + CUresult status = stage_exec_attachments(h_source, &staging); + if (status != CUDA_SUCCESS) { + return status; + } + + { + GILReleaseGuard gil; + status = p_cuGraphExecUpdate(box->resource, *h_source, result_info); + } + if (status != CUDA_SUCCESS) { + return status; + } + + // CUDA may already have retired the old accumulator. Publish the new one + // before releasing the source graph's temporary reference. + box->attachments = staging.accumulator; + return staging.release(); +} + +CUresult graph_prepare_exec_attachment( + const GraphExecHandle& h_exec, + OpaqueHandle owner0, + OpaqueHandle owner1, + PreparedExecAttachment* out_prepared) { + if (!out_prepared) { + return CUDA_ERROR_INVALID_VALUE; + } + out_prepared->reset(); + if (!h_exec) { + return CUDA_ERROR_INVALID_VALUE; + } + + GraphExecBox* box = get_exec_box(h_exec); + if (!box->resource || !box->attachments) { + return CUDA_ERROR_INVALID_VALUE; + } + + ExecAttachments* attachments = box->attachments; + const size_t original_size = attachments->owners.size(); + const size_t additions = + static_cast(static_cast(owner0)) + + static_cast(static_cast(owner1)); + // Reserve before staging so that rollback and commit cannot allocate. + attachments->owners.reserve(original_size + additions); + PreparedExecAttachment prepared( + new PreparedExecAttachmentState(h_exec, attachments, original_size), + PreparedExecAttachmentDeleter{rollback_prepared_exec_attachment}); + if (owner0) { + attachments->owners.emplace_back(std::move(owner0)); + } + if (owner1) { + attachments->owners.emplace_back(std::move(owner1)); + } + *out_prepared = std::move(prepared); + return CUDA_SUCCESS; +} + +void graph_commit_exec_attachment( + PreparedExecAttachment& prepared) noexcept { + delete prepared.release(); +} + namespace { struct GraphNodeBox { mutable CUgraphNode resource; diff --git a/cuda_core/cuda/core/_cpp/resource_handles.hpp b/cuda_core/cuda/core/_cpp/resource_handles.hpp index f2415cd23ac..6a1a0edd6c7 100644 --- a/cuda_core/cuda/core/_cpp/resource_handles.hpp +++ b/cuda_core/cuda/core/_cpp/resource_handles.hpp @@ -108,6 +108,8 @@ extern decltype(&cuLibraryGetKernel) p_cuLibraryGetKernel; // Graph extern decltype(&cuGraphDestroy) p_cuGraphDestroy; +extern decltype(&cuGraphInstantiateWithParams) p_cuGraphInstantiateWithParams; +extern decltype(&cuGraphExecUpdate) p_cuGraphExecUpdate; extern decltype(&cuGraphExecDestroy) p_cuGraphExecDestroy; extern decltype(&cuUserObjectCreate) p_cuUserObjectCreate; extern decltype(&cuUserObjectRelease) p_cuUserObjectRelease; @@ -522,6 +524,21 @@ struct PreparedChildGraphUpdateState; using PreparedChildGraphUpdate = std::shared_ptr; +struct PreparedExecAttachmentState; +using PreparedExecAttachmentRollback = + void (*)(PreparedExecAttachmentState*) noexcept; +struct PreparedExecAttachmentDeleter { + PreparedExecAttachmentRollback rollback = nullptr; + + void operator()(PreparedExecAttachmentState* state) const noexcept { + rollback(state); + } +}; +// Opaque append transaction. Releasing it rolls back newly appended owners +// unless graph_commit_exec_attachment has kept them. +using PreparedExecAttachment = + std::unique_ptr; + // Copy requested owners from node's current attachment. Pass nullptr to ignore // either owner; a missing attachment produces empty handles. CUresult graph_get_attachment( @@ -573,9 +590,39 @@ void invalidate_child_graph_state( // Graph exec handle functions // ============================================================================ -// Wrap an externally-created CUgraphExec with RAII cleanup. -// When the last reference is released, cuGraphExecDestroy is called automatically. -GraphExecHandle create_graph_exec_handle(CUgraphExec graph_exec); +// Create an owning exec handle by calling cuGraphInstantiateWithParams. +// A fresh attachment accumulator is retained on h_source first, because CUDA +// propagates user object references only at instantiation; an exec cannot +// receive them afterwards. The exec is the sole owner once this returns. +// When the last reference is released, cuGraphExecDestroy is called +// automatically. +// Returns empty handle on error (caller must check). The caller reads +// params->result_out for the specific instantiation failure and +// get_last_error() for a driver status. +GraphExecHandle create_graph_exec_handle( + const GraphHandle& h_source, + CUDA_GRAPH_INSTANTIATE_PARAMS* params); + +// Update h_exec in place by calling cuGraphExecUpdate, and publish a fresh +// accumulator when CUDA accepts the update. Writes result_info for the caller. +CUresult graph_exec_update( + const GraphExecHandle& h_exec, + const GraphHandle& h_source, + CUgraphExecUpdateResultInfo* result_info); + +// Append owners before an executable-node mutation. The accumulator grows +// because CUDA cannot attach user objects to an exec after instantiation, so +// old owners stay reachable. Dropping the transaction restores the accumulator +// to its original size. +CUresult graph_prepare_exec_attachment( + const GraphExecHandle& h_exec, + OpaqueHandle owner0, + OpaqueHandle owner1, + PreparedExecAttachment* out_prepared); + +// Keep the owners added by graph_prepare_exec_attachment. +void graph_commit_exec_attachment( + PreparedExecAttachment& prepared) noexcept; // ============================================================================ // Graph node handle functions diff --git a/cuda_core/cuda/core/_resource_handles.pxd b/cuda_core/cuda/core/_resource_handles.pxd index 168aec3d72e..2637abb5137 100644 --- a/cuda_core/cuda/core/_resource_handles.pxd +++ b/cuda_core/cuda/core/_resource_handles.pxd @@ -77,6 +77,14 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": PreparedChildGraphUpdateState ] PreparedChildGraphUpdate + cppclass PreparedExecAttachmentState: + pass + cppclass PreparedExecAttachmentDeleter: + pass + ctypedef unique_ptr[ + PreparedExecAttachmentState, PreparedExecAttachmentDeleter + ] PreparedExecAttachment + # as_cu() - extract the raw CUDA handle (inline C++) cydriver.CUcontext as_cu(ContextHandle h) noexcept nogil cydriver.CUgreenCtx as_cu(GreenCtxHandle h) noexcept nogil @@ -272,7 +280,20 @@ cdef void invalidate_child_graph_state( const GraphHandle& h_parent, cydriver.CUgraphNode owner_node) noexcept # Graph exec handles -cdef GraphExecHandle create_graph_exec_handle(cydriver.CUgraphExec graph_exec) except+ nogil +cdef GraphExecHandle create_graph_exec_handle( + const GraphHandle& h_source, + cydriver.CUDA_GRAPH_INSTANTIATE_PARAMS* params) except+ +cdef cydriver.CUresult graph_exec_update( + const GraphExecHandle& h_exec, + const GraphHandle& h_source, + cydriver.CUgraphExecUpdateResultInfo* result_info) except+ +cdef cydriver.CUresult graph_prepare_exec_attachment( + const GraphExecHandle& h_exec, + OpaqueHandle owner0, + OpaqueHandle owner1, + PreparedExecAttachment* out_prepared) except+ +cdef void graph_commit_exec_attachment( + PreparedExecAttachment& prepared) noexcept # Graph node handles cdef GraphNodeHandle create_graph_node_handle(cydriver.CUgraphNode node, const GraphHandle& h_graph) except+ nogil diff --git a/cuda_core/cuda/core/_resource_handles.pyi b/cuda_core/cuda/core/_resource_handles.pyi index c1bbb3983c9..f9b10d4db3d 100644 --- a/cuda_core/cuda/core/_resource_handles.pyi +++ b/cuda_core/cuda/core/_resource_handles.pyi @@ -27,4 +27,5 @@ TexObjectHandle = shared_ptr SurfObjectHandle = shared_ptr OpaqueHandle = shared_ptr PreparedAttachment = unique_ptr -PreparedChildGraphUpdate = shared_ptr \ No newline at end of file +PreparedChildGraphUpdate = shared_ptr +PreparedExecAttachment = unique_ptr \ No newline at end of file diff --git a/cuda_core/cuda/core/_resource_handles.pyx b/cuda_core/cuda/core/_resource_handles.pyx index a1b0d912a71..464fad6c1bf 100644 --- a/cuda_core/cuda/core/_resource_handles.pyx +++ b/cuda_core/cuda/core/_resource_handles.pyx @@ -178,7 +178,19 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": # Graph exec handles GraphExecHandle create_graph_exec_handle "cuda_core::create_graph_exec_handle" ( - cydriver.CUgraphExec graph_exec) except+ nogil + const GraphHandle& h_source, + cydriver.CUDA_GRAPH_INSTANTIATE_PARAMS* params) except+ + cydriver.CUresult graph_exec_update "cuda_core::graph_exec_update" ( + const GraphExecHandle& h_exec, + const GraphHandle& h_source, + cydriver.CUgraphExecUpdateResultInfo* result_info) except+ + cydriver.CUresult graph_prepare_exec_attachment "cuda_core::graph_prepare_exec_attachment" ( + const GraphExecHandle& h_exec, + OpaqueHandle owner0, + OpaqueHandle owner1, + PreparedExecAttachment* out_prepared) except+ + void graph_commit_exec_attachment "cuda_core::graph_commit_exec_attachment" ( + PreparedExecAttachment& prepared) noexcept # Graph node handles GraphNodeHandle create_graph_node_handle "cuda_core::create_graph_node_handle" ( @@ -328,6 +340,8 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core": # Graph void* p_cuGraphDestroy "reinterpret_cast(cuda_core::p_cuGraphDestroy)" + void* p_cuGraphInstantiateWithParams "reinterpret_cast(cuda_core::p_cuGraphInstantiateWithParams)" + void* p_cuGraphExecUpdate "reinterpret_cast(cuda_core::p_cuGraphExecUpdate)" void* p_cuGraphExecDestroy "reinterpret_cast(cuda_core::p_cuGraphExecDestroy)" void* p_cuUserObjectCreate "reinterpret_cast(cuda_core::p_cuUserObjectCreate)" void* p_cuUserObjectRelease "reinterpret_cast(cuda_core::p_cuUserObjectRelease)" @@ -394,7 +408,8 @@ cdef void _init_driver_fn_pointers() noexcept: global p_cuMemFreeAsync, p_cuMemFree, p_cuMemFreeHost global p_cuMemPoolImportPointer global p_cuLibraryLoadFromFile, p_cuLibraryLoadData, p_cuLibraryUnload, p_cuLibraryGetKernel - global p_cuGraphDestroy, p_cuGraphExecDestroy + global p_cuGraphDestroy, p_cuGraphInstantiateWithParams + global p_cuGraphExecUpdate, p_cuGraphExecDestroy global p_cuUserObjectCreate, p_cuUserObjectRelease global p_cuGraphRetainUserObject, p_cuGraphReleaseUserObject global p_cuGraphNodeFindInClone, p_cuGraphChildGraphNodeGetGraph @@ -457,6 +472,8 @@ cdef void _init_driver_fn_pointers() noexcept: # Graph p_cuGraphDestroy = _get_driver_fn("cuGraphDestroy") + p_cuGraphInstantiateWithParams = _get_driver_fn("cuGraphInstantiateWithParams") + p_cuGraphExecUpdate = _get_driver_fn("cuGraphExecUpdate") p_cuGraphExecDestroy = _get_driver_fn("cuGraphExecDestroy") p_cuUserObjectCreate = _get_driver_fn("cuUserObjectCreate") p_cuUserObjectRelease = _get_driver_fn("cuUserObjectRelease") diff --git a/cuda_core/cuda/core/_utils/_weak_handles.pyi b/cuda_core/cuda/core/_utils/_weak_handles.pyi index 3cf095d7b87..5b7913e008a 100644 --- a/cuda_core/cuda/core/_utils/_weak_handles.pyi +++ b/cuda_core/cuda/core/_utils/_weak_handles.pyi @@ -43,8 +43,9 @@ class WeakHandle: def weak_handle(obj): """Return a :class:`WeakHandle` observing the resource behind ``obj``. - Currently supports :class:`~cuda.core.Buffer` (device allocation handle). - See the module docstring for how to add more types. + Currently supports :class:`~cuda.core.Buffer` (allocation handle) and + :class:`~cuda.core.graph.GraphDefinition` (graph hierarchy handle). See + the module docstring for how to add more types. Raises ------ diff --git a/cuda_core/cuda/core/_utils/_weak_handles.pyx b/cuda_core/cuda/core/_utils/_weak_handles.pyx index 65737b958a6..d9f71e36772 100644 --- a/cuda_core/cuda/core/_utils/_weak_handles.pyx +++ b/cuda_core/cuda/core/_utils/_weak_handles.pyx @@ -23,6 +23,7 @@ Python owners via ``make_opaque_py`` are not covered here -- use """ from cuda.core._memory._buffer cimport Buffer +from cuda.core.graph._graph_definition cimport GraphDefinition from cuda.core._resource_handles cimport OpaqueHandle @@ -85,11 +86,19 @@ cdef WeakHandle _weak_from_buffer(Buffer buf): return _weak_from_opaque(h) +cdef WeakHandle _weak_from_graph_definition(GraphDefinition graph): + cdef OpaqueHandle h = graph._h_graph + if not h: + raise ValueError("GraphDefinition has no active graph") + return _weak_from_opaque(h) + + def weak_handle(obj): """Return a :class:`WeakHandle` observing the resource behind ``obj``. - Currently supports :class:`~cuda.core.Buffer` (device allocation handle). - See the module docstring for how to add more types. + Currently supports :class:`~cuda.core.Buffer` (allocation handle) and + :class:`~cuda.core.graph.GraphDefinition` (graph hierarchy handle). See + the module docstring for how to add more types. Raises ------ @@ -100,7 +109,9 @@ def weak_handle(obj): """ if isinstance(obj, Buffer): return _weak_from_buffer(obj) + if isinstance(obj, GraphDefinition): + return _weak_from_graph_definition(obj) raise TypeError( f"weak_handle() does not support {type(obj).__name__!r}; " - "supported types: Buffer" + "supported types: Buffer, GraphDefinition" ) diff --git a/cuda_core/cuda/core/graph/__init__.pxd b/cuda_core/cuda/core/graph/__init__.pxd index f367745acc1..a018340d20d 100644 --- a/cuda_core/cuda/core/graph/__init__.pxd +++ b/cuda_core/cuda/core/graph/__init__.pxd @@ -11,6 +11,14 @@ from cuda.core.graph._subclasses cimport ( EmptyNode, EventRecordNode, EventWaitNode, + ExecutableChildGraphNode, + ExecutableEventRecordNode, + ExecutableEventWaitNode, + ExecutableGraphNode, + ExecutableHostCallbackNode, + ExecutableKernelNode, + ExecutableMemcpyNode, + ExecutableMemsetNode, FreeNode, HostCallbackNode, IfElseNode, diff --git a/cuda_core/cuda/core/graph/_graph_builder.pxd b/cuda_core/cuda/core/graph/_graph_builder.pxd index 660ebe8ec7d..eb75e6bd44a 100644 --- a/cuda_core/cuda/core/graph/_graph_builder.pxd +++ b/cuda_core/cuda/core/graph/_graph_builder.pxd @@ -24,4 +24,4 @@ cdef class Graph: object __weakref__ @staticmethod - cdef Graph _init(cydriver.CUgraphExec graph_exec) + cdef Graph _init(GraphExecHandle h_graph_exec) diff --git a/cuda_core/cuda/core/graph/_graph_builder.pyi b/cuda_core/cuda/core/graph/_graph_builder.pyi index 4fbc6fb3903..6689082b10b 100644 --- a/cuda_core/cuda/core/graph/_graph_builder.pyi +++ b/cuda_core/cuda/core/graph/_graph_builder.pyi @@ -7,6 +7,8 @@ from dataclasses import dataclass from cuda.core._stream import Stream from cuda.core._utils.cuda_utils import driver from cuda.core.graph._graph_definition import GraphCondition, GraphDefinition +from cuda.core.graph._graph_node import GraphNode +from cuda.core.graph._subclasses import ExecutableGraphNode _BuilderKind = int _CaptureState = int @@ -460,6 +462,15 @@ class Graph: """ + def __getitem__(self, node: GraphNode) -> ExecutableGraphNode: + """Return a view for updating *node* in this executable graph. + + *node* is a definition node from the graph used to instantiate this + executable. Call ``update()`` on the returned view to replace that + node's parameters for future launches. Kernel, memcpy, and memset + views also support enabling and disabling the node. + """ + def update(self, source: 'GraphBuilder | GraphDefinition') -> None: """Update the graph using a new graph definition. @@ -494,7 +505,7 @@ class Graph: """ __all__ = ['Graph', 'GraphBuilder', 'GraphCompleteOptions', 'GraphDebugPrintOptions'] -def _instantiate_graph(h_graph, options: GraphCompleteOptions | None=None) -> Graph: +def _instantiate_graph(source, options: GraphCompleteOptions | None=None) -> Graph: ... def _capture_callback_with_tail_failure_for_testing(gb: GraphBuilder, fn, *, user_data=None): diff --git a/cuda_core/cuda/core/graph/_graph_builder.pyx b/cuda_core/cuda/core/graph/_graph_builder.pyx index 7b7a8445104..1115e3023df 100644 --- a/cuda_core/cuda/core/graph/_graph_builder.pyx +++ b/cuda_core/cuda/core/graph/_graph_builder.pyx @@ -10,15 +10,23 @@ from libc.stdint cimport intptr_t from cuda.bindings cimport cydriver from cuda.core.graph._graph_definition cimport GraphCondition, GraphDefinition +from cuda.core.graph._graph_node cimport GraphNode from cuda.core.graph._host_callback cimport _resolve_host_callback +from cuda.core.graph._subclasses cimport ( + ExecutableGraphNode, + create_executable_node_view, +) from cuda.core._resource_handles cimport ( + GraphExecHandle, GraphHandle, OpaqueHandle, PreparedAttachment, as_cu, as_py, create_child_graph_handle, create_graph_exec_handle, create_graph_handle, + get_last_error, graph_clone_attachments, graph_commit_attachment, + graph_exec_update, graph_prepare_attachment, invalidate_child_graph_state, retry_deferred_cleanup, @@ -161,25 +169,40 @@ class GraphCompleteOptions: use_node_priority: bool = False -def _instantiate_graph(h_graph, options: GraphCompleteOptions | None = None) -> Graph: - params = driver.CUDA_GRAPH_INSTANTIATE_PARAMS() +def _instantiate_graph(source, options: GraphCompleteOptions | None = None) -> Graph: + cdef GraphHandle h_graph + cdef GraphExecHandle h_exec + + if isinstance(source, GraphBuilder): + h_graph = (source)._h_graph + elif isinstance(source, GraphDefinition): + h_graph = (source)._h_graph + else: + raise TypeError( + f"expected GraphBuilder or GraphDefinition, got {type(source).__name__}") + + cdef cydriver.CUDA_GRAPH_INSTANTIATE_PARAMS params = cydriver.CUDA_GRAPH_INSTANTIATE_PARAMS( + flags=0, + hUploadStream=NULL, + hErrNode_out=NULL, + result_out=cydriver.CUgraphInstantiateResult.CUDA_GRAPH_INSTANTIATE_SUCCESS, + ) if options: flags = 0 if options.auto_free_on_launch: flags |= driver.CUgraphInstantiate_flags.CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH if options.upload_stream: flags |= driver.CUgraphInstantiate_flags.CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD - params.hUploadStream = options.upload_stream.handle + params.hUploadStream = as_cu((options.upload_stream)._h_stream) if options.device_launch: flags |= driver.CUgraphInstantiate_flags.CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH if options.use_node_priority: flags |= driver.CUgraphInstantiate_flags.CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY params.flags = flags - py_exec = handle_return(driver.cuGraphInstantiateWithParams(h_graph, params)) - # Check result_out before wrapping the exec: on a non-SUCCESS result the exec - # may be invalid, and Graph._init's RAII deleter would call cuGraphExecDestroy - # on it during the exception unwind below. + # The exec is adopted only when result_out reports success, so the + # diagnostics below run before the handle is checked. + h_exec = create_graph_exec_handle(h_graph, ¶ms) if params.result_out == driver.CUgraphInstantiateResult.CUDA_GRAPH_INSTANTIATE_ERROR: raise RuntimeError( "Instantiation failed for an unexpected reason which is described in the return value of the function." @@ -200,8 +223,9 @@ def _instantiate_graph(h_graph, options: GraphCompleteOptions | None = None) -> elif params.result_out != driver.CUgraphInstantiateResult.CUDA_GRAPH_INSTANTIATE_SUCCESS: raise RuntimeError(f"Graph instantiation failed with unexpected error code: {params.result_out}") - cdef cydriver.CUgraphExec c_exec = int(py_exec) - return Graph._init(c_exec) + if as_cu(h_exec) == NULL: + HANDLE_RETURN(get_last_error()) + return Graph._init(h_exec) # Distinguishes the three kinds of GraphBuilder, which differ in how they @@ -473,7 +497,7 @@ cdef class GraphBuilder: if self._state != CAPTURE_ENDED: raise RuntimeError("Graph has not finished building.") - return _instantiate_graph(as_py(self._h_graph), options) + return _instantiate_graph(self, options) def debug_dot_print(self, path: str, options: GraphDebugPrintOptions | None = None) -> None: """Generates a DOT debug file for the graph builder. @@ -1059,9 +1083,9 @@ cdef class Graph: raise RuntimeError("directly constructing a Graph instance is not supported") @staticmethod - cdef Graph _init(cydriver.CUgraphExec graph_exec): + cdef Graph _init(GraphExecHandle h_graph_exec): cdef Graph self = Graph.__new__(Graph) - self._h_graph_exec = create_graph_exec_handle(graph_exec) + self._h_graph_exec = h_graph_exec return self def close(self) -> None: @@ -1081,6 +1105,17 @@ cdef class Graph: """ return as_py(self._h_graph_exec) + def __getitem__(self, node: GraphNode) -> ExecutableGraphNode: + """Return a view for updating *node* in this executable graph. + + *node* is a definition node from the graph used to instantiate this + executable. Call ``update()`` on the returned view to replace that + node's parameters for future launches. Kernel, memcpy, and memset + views also support enabling and disabling the node. + """ + return create_executable_node_view( + self._h_graph_exec, node) + def update(self, source: "GraphBuilder | GraphDefinition") -> None: """Update the graph using a new graph definition. @@ -1093,27 +1128,23 @@ cdef class Graph: finished building. """ - from cuda.core.graph import GraphDefinition - - cdef cydriver.CUgraph cu_graph - cdef cydriver.CUgraphExec cu_exec = as_cu(self._h_graph_exec) + cdef GraphHandle h_source if isinstance(source, GraphBuilder): if (source)._state == CLOSED: raise ValueError("Source graph builder has been closed.") if (source)._state != CAPTURE_ENDED: raise ValueError("Graph has not finished building.") - cu_graph = as_cu((source)._h_graph) + h_source = (source)._h_graph elif isinstance(source, GraphDefinition): - cu_graph = int(source.handle) + h_source = (source)._h_graph else: raise TypeError( f"expected GraphBuilder or GraphDefinition, got {type(source).__name__}") cdef cydriver.CUgraphExecUpdateResultInfo result_info - cdef cydriver.CUresult err - with nogil: - err = cydriver.cuGraphExecUpdate(cu_exec, cu_graph, &result_info) + cdef cydriver.CUresult err = graph_exec_update( + self._h_graph_exec, h_source, &result_info) if err == cydriver.CUresult.CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE: reason = driver.CUgraphExecUpdateResult(result_info.result) msg = f"Graph update failed: {reason.__doc__.strip()} ({reason.name})" diff --git a/cuda_core/cuda/core/graph/_graph_definition.pyx b/cuda_core/cuda/core/graph/_graph_definition.pyx index b2516034d61..46896899ecd 100644 --- a/cuda_core/cuda/core/graph/_graph_definition.pyx +++ b/cuda_core/cuda/core/graph/_graph_definition.pyx @@ -327,8 +327,7 @@ cdef class GraphDefinition: """ from cuda.core.graph._graph_builder import _instantiate_graph - return _instantiate_graph( - driver.CUgraph(as_intptr(self._h_graph)), options) + return _instantiate_graph(self, options) def debug_dot_print(self, path: str, options: GraphDebugPrintOptions | None = None) -> None: """Write a GraphViz DOT representation of the graph to a file. diff --git a/cuda_core/cuda/core/graph/_subclasses.pxd b/cuda_core/cuda/core/graph/_subclasses.pxd index 7f84b713429..7f92eafe7e8 100644 --- a/cuda_core/cuda/core/graph/_subclasses.pxd +++ b/cuda_core/cuda/core/graph/_subclasses.pxd @@ -7,7 +7,13 @@ from libc.stddef cimport size_t from cuda.bindings cimport cydriver from cuda.core.graph._graph_definition cimport GraphCondition from cuda.core.graph._graph_node cimport GraphNode -from cuda.core._resource_handles cimport EventHandle, GraphHandle, GraphNodeHandle, KernelHandle +from cuda.core._resource_handles cimport ( + EventHandle, + GraphExecHandle, + GraphHandle, + GraphNodeHandle, + KernelHandle, +) cdef class EmptyNode(GraphNode): @@ -172,3 +178,41 @@ cdef class WhileNode(ConditionalNode): cdef class SwitchNode(ConditionalNode): pass + + +cdef class ExecutableGraphNode: + cdef: + GraphExecHandle _h_graph_exec + GraphNodeHandle _h_node + + +cdef class ExecutableKernelNode(ExecutableGraphNode): + pass + + +cdef class ExecutableMemsetNode(ExecutableGraphNode): + pass + + +cdef class ExecutableMemcpyNode(ExecutableGraphNode): + pass + + +cdef class ExecutableChildGraphNode(ExecutableGraphNode): + pass + + +cdef class ExecutableEventRecordNode(ExecutableGraphNode): + pass + + +cdef class ExecutableEventWaitNode(ExecutableGraphNode): + pass + + +cdef class ExecutableHostCallbackNode(ExecutableGraphNode): + pass + + +cdef ExecutableGraphNode create_executable_node_view( + const GraphExecHandle& h_exec, GraphNode node) diff --git a/cuda_core/cuda/core/graph/_subclasses.pyi b/cuda_core/cuda/core/graph/_subclasses.pyi index 2e6d4dd9529..ebe0adb01c9 100644 --- a/cuda_core/cuda/core/graph/_subclasses.pyi +++ b/cuda_core/cuda/core/graph/_subclasses.pyi @@ -416,4 +416,101 @@ class SwitchNode(ConditionalNode): def __repr__(self) -> str: ... -__all__ = ['AllocNode', 'ChildGraphNode', 'ConditionalNode', 'EmptyNode', 'EventRecordNode', 'EventWaitNode', 'FreeNode', 'HostCallbackNode', 'IfElseNode', 'IfNode', 'KernelNode', 'MemcpyNode', 'MemsetNode', 'SwitchNode', 'WhileNode'] \ No newline at end of file + +class ExecutableGraphNode: + """A lightweight view pairing an executable graph with a source node. + + Create executable-node views with ``graph[node]``. CUDA validates that the + node identifies a node in the executable graph when an operation is + performed. + """ + + def __init__(self): + ... + + def __repr__(self) -> str: + ... + +class ExecutableKernelNode(ExecutableGraphNode): + """An executable kernel-node view.""" + + def update(self, *, config: LaunchConfig, kernel: Kernel, args) -> None: + """Replace all kernel launch parameters for future launches. + + ``args`` must contain the complete argument sequence; use ``args=()`` + for a no-argument kernel. Clustered and cooperative launch + configurations are not supported. + """ + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + + def enable(self) -> None: + """Enable this node in the executable graph.""" + + def disable(self) -> None: + """Disable this node in the executable graph.""" + +class ExecutableMemsetNode(ExecutableGraphNode): + """An executable memset-node view.""" + + def update(self, *, dst: Buffer | int, value, width: int, height: int=1, pitch: int=0) -> None: + """Replace all memset parameters for future launches.""" + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + + def enable(self) -> None: + """Enable this node in the executable graph.""" + + def disable(self) -> None: + """Disable this node in the executable graph.""" + +class ExecutableMemcpyNode(ExecutableGraphNode): + """An executable memcpy-node view.""" + + def update(self, *, dst: Buffer | int, src: Buffer | int, size: int) -> None: + """Replace all one-dimensional memcpy parameters for future launches.""" + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + + def enable(self) -> None: + """Enable this node in the executable graph.""" + + def disable(self) -> None: + """Disable this node in the executable graph.""" + +class ExecutableChildGraphNode(ExecutableGraphNode): + """An executable child-graph-node view.""" + + def update(self, child: GraphDefinition) -> None: + """Replace the embedded graph parameters for future launches.""" + +class ExecutableEventRecordNode(ExecutableGraphNode): + """An executable event-record-node view.""" + + def update(self, event: Event) -> None: + """Replace the event recorded by future launches.""" + +class ExecutableEventWaitNode(ExecutableGraphNode): + """An executable event-wait-node view.""" + + def update(self, event: Event) -> None: + """Replace the event waited on by future launches.""" + +class ExecutableHostCallbackNode(ExecutableGraphNode): + """An executable host-callback-node view.""" + + def update(self, fn, *, user_data=None) -> None: + """Replace the callback and user-data binding for future launches. + + .. warning:: + + Callbacks must not call CUDA API functions. Doing so may deadlock + or corrupt driver state. + """ +__all__ = ['AllocNode', 'ChildGraphNode', 'ConditionalNode', 'EmptyNode', 'EventRecordNode', 'EventWaitNode', 'ExecutableChildGraphNode', 'ExecutableEventRecordNode', 'ExecutableEventWaitNode', 'ExecutableGraphNode', 'ExecutableHostCallbackNode', 'ExecutableKernelNode', 'ExecutableMemcpyNode', 'ExecutableMemsetNode', 'FreeNode', 'HostCallbackNode', 'IfElseNode', 'IfNode', 'KernelNode', 'MemcpyNode', 'MemsetNode', 'SwitchNode', 'WhileNode'] \ No newline at end of file diff --git a/cuda_core/cuda/core/graph/_subclasses.pyx b/cuda_core/cuda/core/graph/_subclasses.pyx index 04b2cc908dc..b0630165671 100644 --- a/cuda_core/cuda/core/graph/_subclasses.pyx +++ b/cuda_core/cuda/core/graph/_subclasses.pyx @@ -21,16 +21,19 @@ from cuda.core.graph._graph_definition cimport GraphCondition, GraphDefinition from cuda.core.graph._graph_node cimport ( GraphNode, _get_memcpy_memory_type, + _init_memcpy_params, _resolve_memcpy_operand, ) from cuda.core._resource_handles cimport ( EventHandle, + GraphExecHandle, GraphHandle, GraphNodeHandle, KernelHandle, OpaqueHandle, PreparedAttachment, PreparedChildGraphUpdate, + PreparedExecAttachment, as_cu, as_intptr, create_child_graph_handle, @@ -38,10 +41,12 @@ from cuda.core._resource_handles cimport ( create_kernel_handle_ref, graph_commit_attachment, graph_commit_child_graph_update, + graph_commit_exec_attachment, graph_get_attachment, graph_node_get_graph, graph_prepare_attachment, graph_prepare_child_graph_update, + graph_prepare_exec_attachment, make_opaque_py, ) from cuda.core._utils.cuda_utils cimport HANDLE_RETURN, _parse_fill_value @@ -62,6 +67,14 @@ __all__ = [ 'EmptyNode', 'EventRecordNode', 'EventWaitNode', + 'ExecutableChildGraphNode', + 'ExecutableEventRecordNode', + 'ExecutableEventWaitNode', + 'ExecutableGraphNode', + 'ExecutableHostCallbackNode', + 'ExecutableKernelNode', + 'ExecutableMemcpyNode', + 'ExecutableMemsetNode', 'FreeNode', 'HostCallbackNode', 'IfElseNode', @@ -125,6 +138,69 @@ cdef void _set_definition_node_params( HANDLE_RETURN(graph_commit_attachment(prepared, node)) +cdef void _set_executable_node_params( + const GraphExecHandle& h_exec, + const GraphNodeHandle& h_node, + cydriver.CUgraphNodeParams* params, + OpaqueHandle owner0=OpaqueHandle(), + OpaqueHandle owner1=OpaqueHandle()) except *: + _require_graph_node_update_support() + + cdef cydriver.CUgraphExec graph_exec = as_cu(h_exec) + cdef cydriver.CUgraphNode node = as_cu(h_node) + if graph_exec == NULL: + raise ValueError("executable graph has been closed") + if node == NULL: + raise ValueError("source graph node is no longer valid") + + cdef PreparedExecAttachment prepared + HANDLE_RETURN(graph_prepare_exec_attachment( + h_exec, owner0, owner1, &prepared)) + + cdef cydriver.CUresult status + with nogil: + status = cydriver.cuGraphExecNodeSetParams( + graph_exec, node, params) + if status == cydriver.CUDA_SUCCESS: + graph_commit_exec_attachment(prepared) + HANDLE_RETURN(status) + + +cdef bint _get_executable_node_enabled( + const GraphExecHandle& h_exec, + const GraphNodeHandle& h_node) except *: + _require_graph_node_update_support() + + cdef cydriver.CUgraphExec graph_exec = as_cu(h_exec) + cdef cydriver.CUgraphNode node = as_cu(h_node) + cdef unsigned int enabled + if graph_exec == NULL: + raise ValueError("executable graph has been closed") + if node == NULL: + raise ValueError("source graph node is no longer valid") + with nogil: + HANDLE_RETURN(cydriver.cuGraphNodeGetEnabled( + graph_exec, node, &enabled)) + return enabled != 0 + + +cdef void _set_executable_node_enabled( + const GraphExecHandle& h_exec, + const GraphNodeHandle& h_node, + bint enabled) except *: + _require_graph_node_update_support() + + cdef cydriver.CUgraphExec graph_exec = as_cu(h_exec) + cdef cydriver.CUgraphNode node = as_cu(h_node) + if graph_exec == NULL: + raise ValueError("executable graph has been closed") + if node == NULL: + raise ValueError("source graph node is no longer valid") + with nogil: + HANDLE_RETURN(cydriver.cuGraphNodeSetEnabled( + graph_exec, node, enabled)) + + cdef bint _check_node_get_params(): global _has_cuGraphNodeGetParams, _version_checked if not _version_checked: @@ -1285,3 +1361,298 @@ cdef class SwitchNode(ConditionalNode): def __repr__(self) -> str: return (f"self._condition._c_handle:x}>") + + +cdef class ExecutableGraphNode: + """A lightweight view pairing an executable graph with a source node. + + Create executable-node views with ``graph[node]``. CUDA validates that the + node identifies a node in the executable graph when an operation is + performed. + """ + + def __init__(self): + raise RuntimeError( + "directly constructing an executable graph node is not supported") + + def __repr__(self) -> str: + return ( + f"<{type(self).__name__} graph=0x{as_intptr(self._h_graph_exec):x}" + f" node=0x{as_intptr(self._h_node):x}>" + ) + + +cdef class ExecutableKernelNode(ExecutableGraphNode): + """An executable kernel-node view.""" + + def update( + self, + *, + config: LaunchConfig, + kernel: Kernel, + args, + ) -> None: + """Replace all kernel launch parameters for future launches. + + ``args`` must contain the complete argument sequence; use ``args=()`` + for a no-argument kernel. Clustered and cooperative launch + configurations are not supported. + """ + cdef LaunchConfig c_config = config + cdef Kernel c_kernel = kernel + cdef ParamHolder arg_holder + cdef object kernel_args + cdef OpaqueHandle kernel_owner = c_kernel._h_kernel + cdef OpaqueHandle args_owner + cdef cydriver.CUgraphNodeParams params + + if c_config.cluster is not None or c_config.is_cooperative: + raise NotImplementedError( + "updating clustered or cooperative kernel nodes is not " + "supported") + arg_holder = ParamHolder(args) + + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_KERNEL + params.kernel.kern = as_cu(c_kernel._h_kernel) + params.kernel.func = NULL + params.kernel.gridDimX = c_config.grid[0] + params.kernel.gridDimY = c_config.grid[1] + params.kernel.gridDimZ = c_config.grid[2] + params.kernel.blockDimX = c_config.block[0] + params.kernel.blockDimY = c_config.block[1] + params.kernel.blockDimZ = c_config.block[2] + params.kernel.sharedMemBytes = c_config.shmem_size + params.kernel.kernelParams = arg_holder.ptr + params.kernel.extra = NULL + params.kernel.ctx = NULL + + kernel_args = arg_holder.kernel_args + if kernel_args is not None: + args_owner = make_opaque_py(kernel_args) + _set_executable_node_params( + self._h_graph_exec, self._h_node, ¶ms, + kernel_owner, args_owner) + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + return _get_executable_node_enabled( + self._h_graph_exec, self._h_node) + + def enable(self) -> None: + """Enable this node in the executable graph.""" + _set_executable_node_enabled( + self._h_graph_exec, self._h_node, True) + + def disable(self) -> None: + """Disable this node in the executable graph.""" + _set_executable_node_enabled( + self._h_graph_exec, self._h_node, False) + + +cdef class ExecutableMemsetNode(ExecutableGraphNode): + """An executable memset-node view.""" + + def update( + self, + *, + dst: Buffer | int, + value, + size_t width, + size_t height=1, + size_t pitch=0, + ) -> None: + """Replace all memset parameters for future launches.""" + cdef cydriver.CUdeviceptr c_dst + cdef OpaqueHandle dst_owner = _resolve_memcpy_operand( + dst, None, "dst", &c_dst) + cdef unsigned int c_value + cdef unsigned int element_size + c_value, element_size = _parse_fill_value(value) + + cdef cydriver.CUcontext ctx = NULL + cdef cydriver.CUgraphNodeParams params + with nogil: + HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) + + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_MEMSET + params.memset.dst = c_dst + params.memset.value = c_value + params.memset.elementSize = element_size + params.memset.width = width + params.memset.height = height + params.memset.pitch = pitch + params.memset.ctx = ctx + _set_executable_node_params( + self._h_graph_exec, self._h_node, ¶ms, dst_owner) + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + return _get_executable_node_enabled( + self._h_graph_exec, self._h_node) + + def enable(self) -> None: + """Enable this node in the executable graph.""" + _set_executable_node_enabled( + self._h_graph_exec, self._h_node, True) + + def disable(self) -> None: + """Disable this node in the executable graph.""" + _set_executable_node_enabled( + self._h_graph_exec, self._h_node, False) + + +cdef class ExecutableMemcpyNode(ExecutableGraphNode): + """An executable memcpy-node view.""" + + def update( + self, + *, + dst: Buffer | int, + src: Buffer | int, + size_t size, + ) -> None: + """Replace all one-dimensional memcpy parameters for future launches.""" + cdef cydriver.CUdeviceptr c_dst + cdef cydriver.CUdeviceptr c_src + cdef OpaqueHandle dst_owner = _resolve_memcpy_operand( + dst, None, "dst", &c_dst) + cdef OpaqueHandle src_owner = _resolve_memcpy_operand( + src, None, "src", &c_src) + cdef cydriver.CUmemorytype dst_type + cdef cydriver.CUmemorytype src_type + cdef cydriver.CUcontext ctx = NULL + cdef cydriver.CUgraphNodeParams params + + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_MEMCPY + _init_memcpy_params( + c_dst, c_src, size, ¶ms.memcpy.copyParams, + &dst_type, &src_type) + with nogil: + HANDLE_RETURN(cydriver.cuCtxGetCurrent(&ctx)) + params.memcpy.copyCtx = ctx + _set_executable_node_params( + self._h_graph_exec, self._h_node, ¶ms, + dst_owner, src_owner) + + @property + def is_enabled(self) -> bool: + """Whether this node is enabled in the executable graph.""" + return _get_executable_node_enabled( + self._h_graph_exec, self._h_node) + + def enable(self) -> None: + """Enable this node in the executable graph.""" + _set_executable_node_enabled( + self._h_graph_exec, self._h_node, True) + + def disable(self) -> None: + """Disable this node in the executable graph.""" + _set_executable_node_enabled( + self._h_graph_exec, self._h_node, False) + + +cdef class ExecutableChildGraphNode(ExecutableGraphNode): + """An executable child-graph-node view.""" + + def update(self, child: GraphDefinition) -> None: + """Replace the embedded graph parameters for future launches.""" + cdef cydriver.CUgraphNodeParams params + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_GRAPH + params.graph.graph = as_cu(child._h_graph) + _set_executable_node_params( + self._h_graph_exec, self._h_node, ¶ms) + + +cdef class ExecutableEventRecordNode(ExecutableGraphNode): + """An executable event-record-node view.""" + + def update(self, event: Event) -> None: + """Replace the event recorded by future launches.""" + cdef OpaqueHandle event_owner = event._h_event + cdef cydriver.CUgraphNodeParams params + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_EVENT_RECORD + params.eventRecord.event = as_cu(event._h_event) + _set_executable_node_params( + self._h_graph_exec, self._h_node, ¶ms, event_owner) + + +cdef class ExecutableEventWaitNode(ExecutableGraphNode): + """An executable event-wait-node view.""" + + def update(self, event: Event) -> None: + """Replace the event waited on by future launches.""" + cdef OpaqueHandle event_owner = event._h_event + cdef cydriver.CUgraphNodeParams params + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_WAIT_EVENT + params.eventWait.event = as_cu(event._h_event) + _set_executable_node_params( + self._h_graph_exec, self._h_node, ¶ms, event_owner) + + +cdef class ExecutableHostCallbackNode(ExecutableGraphNode): + """An executable host-callback-node view.""" + + def update(self, fn, *, user_data=None) -> None: + """Replace the callback and user-data binding for future launches. + + .. warning:: + + Callbacks must not call CUDA API functions. Doing so may deadlock + or corrupt driver state. + """ + cdef cydriver.CUhostFn c_fn + cdef void* c_user_data + cdef OpaqueHandle fn_owner + cdef OpaqueHandle data_owner + cdef cydriver.CUgraphNodeParams params + + _resolve_host_callback( + fn, user_data, &c_fn, &c_user_data, &fn_owner, &data_owner) + c_memset(¶ms, 0, sizeof(params)) + params.type = cydriver.CU_GRAPH_NODE_TYPE_HOST + params.host.fn = c_fn + params.host.userData = c_user_data + _set_executable_node_params( + self._h_graph_exec, self._h_node, ¶ms, + fn_owner, data_owner) + + +cdef ExecutableGraphNode create_executable_node_view( + const GraphExecHandle& h_exec, + GraphNode node): + cdef type view_type + if isinstance(node, KernelNode): + view_type = ExecutableKernelNode + elif isinstance(node, MemsetNode): + view_type = ExecutableMemsetNode + elif isinstance(node, MemcpyNode): + view_type = ExecutableMemcpyNode + elif isinstance(node, ChildGraphNode): + view_type = ExecutableChildGraphNode + elif isinstance(node, EventRecordNode): + view_type = ExecutableEventRecordNode + elif isinstance(node, EventWaitNode): + view_type = ExecutableEventWaitNode + elif isinstance(node, HostCallbackNode): + view_type = ExecutableHostCallbackNode + else: + raise TypeError( + f"{type(node).__name__} does not support executable updates") + + if as_cu(h_exec) == NULL: + raise ValueError("executable graph has been closed") + if as_cu(node._h_node) == NULL: + raise ValueError("source graph node is no longer valid") + + cdef ExecutableGraphNode view = view_type.__new__(view_type) + view._h_graph_exec = h_exec + view._h_node = node._h_node + return view diff --git a/cuda_core/docs/source/api.rst b/cuda_core/docs/source/api.rst index da18ee27c80..e903a46a7ee 100644 --- a/cuda_core/docs/source/api.rst +++ b/cuda_core/docs/source/api.rst @@ -191,6 +191,41 @@ nodes also cannot currently be constructed explicitly. graph.WhileNode graph.SwitchNode +Executable node views +````````````````````` + +Index an executable :class:`~graph.Graph` with a definition node to update that +node in the executable, for example +``graph[kernel_node].update(config=config, kernel=kernel, args=args)``. +The returned view retains the executable and source node, while CUDA validates +that the node is associated with the executable. + +Executable graphs do not support reading back current node parameters, so +updates take a complete replacement. Buffer operands, kernels, events, kernel +arguments, and callback bindings are retained for every future launch that may +use them. Superseded resources remain retained until a successful whole-graph +update or executable destruction. Raw integer addresses remain caller-owned. +Memcpy and memset updates use the current CUDA context, which must match the +original node context. + +Kernel, memcpy, and memset views also provide ``is_enabled``, ``enable()``, and +``disable()``. Executable-node updates require CUDA driver and +``cuda.bindings`` versions 12.2 or newer. + +.. autosummary:: + :toctree: generated/ + + :template: autosummary/cyclass.rst + + graph.ExecutableGraphNode + graph.ExecutableKernelNode + graph.ExecutableMemcpyNode + graph.ExecutableMemsetNode + graph.ExecutableHostCallbackNode + graph.ExecutableChildGraphNode + graph.ExecutableEventRecordNode + graph.ExecutableEventWaitNode + Graphics interoperability ------------------------- diff --git a/cuda_core/docs/source/release/1.2.0-notes.rst b/cuda_core/docs/source/release/1.2.0-notes.rst index 4622d837c35..4bb81cec759 100644 --- a/cuda_core/docs/source/release/1.2.0-notes.rst +++ b/cuda_core/docs/source/release/1.2.0-notes.rst @@ -25,7 +25,16 @@ Fixes and enhancements versions 12.2 or newer. (`#2352 `__) -<<<<<<< HEAD +- Added ``graph[node]`` views for updating nodes in an executable graph. + Kernel, memcpy, memset, child-graph, event, and host-callback parameters can + be replaced without reinstantiating the graph. Kernel, memcpy, and memset + nodes can also be enabled or disabled. Resources introduced by these updates + remain alive through in-flight launches. Superseded resources stay retained + until a successful whole-graph update or executable graph destruction. This + feature requires CUDA driver and ``cuda.bindings`` versions 12.2 or newer. + (`#2353 `__, + `#2354 `__) + - The default-stream singletons ``LEGACY_DEFAULT_STREAM`` and ``PER_THREAD_DEFAULT_STREAM`` no longer cache the first context and device they observe. A default-stream token refers to whatever context is current, @@ -34,7 +43,7 @@ Fixes and enhancements Previously the first query pinned the singleton to one context for the lifetime of the process, which also kept that context alive. (`#2485 `__) -======= + - :meth:`Linker.which_backend` and constructing a :class:`Linker` no longer raise ``FunctionNotFoundError`` when an nvJitLink older than 12.3 (12.0–12.2) is installed. These versions do not export the unversioned @@ -43,7 +52,6 @@ Fixes and enhancements (``cuLink``) backend, restoring the pre-0.7.0 behavior. (`#2409 `__, closes `#2408 `__) ->>>>>>> origin/main Deprecation Notices ------------------- diff --git a/cuda_core/tests/graph/test_graph_node_update.py b/cuda_core/tests/graph/test_graph_node_update.py index 2dce7a39317..f34b9ce7f93 100644 --- a/cuda_core/tests/graph/test_graph_node_update.py +++ b/cuda_core/tests/graph/test_graph_node_update.py @@ -4,7 +4,10 @@ """Tests for updating individual graph node parameters.""" import ctypes +import gc import threading +import time +import weakref from dataclasses import dataclass from typing import Callable @@ -12,9 +15,19 @@ from helpers.graph_kernels import compile_common_kernels from cuda.core import LaunchConfig, LegacyPinnedMemoryResource +from cuda.core._utils._weak_handles import weak_handle from cuda.core._utils.cuda_utils import CUDAError, driver, handle_return from cuda.core._utils.version import driver_version -from cuda.core.graph import GraphDefinition, HostCallbackNode +from cuda.core.graph import ( + ChildGraphNode, + EventRecordNode, + EventWaitNode, + GraphDefinition, + HostCallbackNode, + KernelNode, + MemcpyNode, + MemsetNode, +) @dataclass @@ -35,6 +48,51 @@ def _assert_equal(actual, expected): assert actual == expected +def _wait_until(predicate, timeout=5.0): + deadline = time.monotonic() + timeout + while not predicate(): + if time.monotonic() >= deadline: + raise AssertionError(f"condition not satisfied within {timeout}s") + gc.collect() + time.sleep(0.02) + + +def _update_executable_case(graph, case): + view = graph[case.node] + replacement = case.replacement + if isinstance(case.node, (EventRecordNode, EventWaitNode)): + view.update(replacement) + elif isinstance(case.node, HostCallbackNode): + if isinstance(replacement, tuple): + view.update(replacement[0], user_data=replacement[1]) + else: + view.update(replacement) + elif isinstance(case.node, MemsetNode): + view.update( + dst=replacement["dst"], + value=replacement["value"], + width=replacement["width"], + height=replacement["height"], + pitch=replacement["pitch"], + ) + elif isinstance(case.node, MemcpyNode): + view.update( + dst=replacement["dst"], + src=replacement["src"], + size=replacement["size"], + ) + elif isinstance(case.node, KernelNode): + view.update( + config=replacement["config"], + kernel=replacement["kernel"], + args=replacement["args"], + ) + elif isinstance(case.node, ChildGraphNode): + view.update(replacement["child"]) + else: # pragma: no cover - fixture cases are exhaustive + raise AssertionError(f"unsupported case: {type(case.node).__name__}") + + def _event_record_case(device): """Keep the selected event pending to identify each exec's record target.""" original = device.create_event() @@ -739,3 +797,423 @@ def test_definition_node_update_rejects_wrong_type( pytest.skip("update method has no typed positional argument") with pytest.raises(TypeError): definition_update_case.invalid_argument_update() + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_executable_node_update_changes_existing_exec( + definition_update_case, +): + case = definition_update_case + graph = case.graph_def.instantiate() + + _update_executable_case(graph, case) + + case.assert_current(case.original) + case.assert_exec_uses(graph, case.replacement) + + +@pytest.mark.parametrize("node_kind", ["kernel", "memcpy", "memset"]) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_executable_node_enable_state(init_cuda, node_kind): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + graph_def = GraphDefinition() + if node_kind == "kernel": + kernel = compile_common_kernels().get_kernel("empty_kernel") + node = graph_def.launch(LaunchConfig(grid=1, block=1), kernel) + else: + memory_resource = LegacyPinnedMemoryResource() + src = memory_resource.allocate(4) + dst = memory_resource.allocate(4) + if node_kind == "memcpy": + node = graph_def.memcpy(dst, src, 4) + else: + node = graph_def.memset(dst, 0, 4) + + view = graph_def.instantiate()[node] + assert view.is_enabled + view.disable() + assert not view.is_enabled + view.disable() + assert not view.is_enabled + view.enable() + assert view.is_enabled + view.enable() + assert view.is_enabled + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_executable_node_view_rejects_unsupported_and_destroyed_nodes( + init_cuda, +): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + kernel = compile_common_kernels().get_kernel("empty_kernel") + graph_def = GraphDefinition() + empty = graph_def.empty() + kernel_node = graph_def.launch(LaunchConfig(grid=1, block=1), kernel) + graph = graph_def.instantiate() + + with pytest.raises(TypeError, match="does not support executable updates"): + graph[empty] + with pytest.raises(TypeError): + graph[object()] + + kernel_node.destroy() + with pytest.raises(ValueError, match="no longer valid"): + graph[kernel_node] + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_executable_node_view_retains_source_only_while_live(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + called = [] + + def original(): + called.append("original") + + def replacement(): + called.append("replacement") + + source = GraphDefinition() + node = source.callback(original) + source_weak = weak_handle(source) + graph = source.instantiate() + view = graph[node] + + del source, node + gc.collect() + assert source_weak + + view.update(replacement) + del view + _wait_until(lambda: not source_weak) + + stream = init_cuda.create_stream() + graph.launch(stream) + stream.sync() + assert called == ["replacement"] + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_executable_attachment_accumulators_are_independent(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + called = [] + + def original(): + called.append("original") + + def first_replacement(): + called.append("first") + + def second_replacement(): + called.append("second") + + first_weak = weakref.ref(first_replacement) + second_weak = weakref.ref(second_replacement) + source = GraphDefinition() + node = source.callback(original) + first = source.instantiate() + second = source.instantiate() + + first[node].update(first_replacement) + second[node].update(second_replacement) + del first_replacement, second_replacement, original, node, source + gc.collect() + assert first_weak() is not None + assert second_weak() is not None + + stream = init_cuda.create_stream() + first.launch(stream) + second.launch(stream) + stream.sync() + assert called == ["first", "second"] + + del first + _wait_until(lambda: first_weak() is None) + assert second_weak() is not None + + del second + _wait_until(lambda: second_weak() is None) + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_rejected_executable_update_rolls_back_owners(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + kernel = compile_common_kernels().get_kernel("add_one") + config = LaunchConfig(grid=1, block=1) + memory_resource = LegacyPinnedMemoryResource() + active = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) + rejected = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) + ctypes.c_int.from_address(int(active.handle)).value = 0 + rejected_weak = weak_handle(rejected) + + source = GraphDefinition() + source.launch(config, kernel, active) + graph = source.instantiate() + unrelated = GraphDefinition() + unrelated_node = unrelated.launch(config, kernel, active) + + with pytest.raises(CUDAError): + graph[unrelated_node].update(config=config, kernel=kernel, args=(rejected,)) + + del rejected + _wait_until(lambda: not rejected_weak) + + stream = init_cuda.create_stream() + graph.launch(stream) + stream.sync() + assert ctypes.c_int.from_address(int(active.handle)).value == 1 + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_whole_update_replaces_executable_attachment_accumulator(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + called = [] + + def original(): + called.append("original") + + def individual(): + called.append("individual") + + def whole(): + called.append("whole") + + individual_weak = weakref.ref(individual) + source = GraphDefinition() + node = source.callback(original) + graph = source.instantiate() + graph[node].update(individual) + + replacement = GraphDefinition() + replacement.callback(whole) + del individual + graph.update(replacement) + _wait_until(lambda: individual_weak() is None) + + stream = init_cuda.create_stream() + graph.launch(stream) + stream.sync() + assert called == ["whole"] + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_failed_whole_update_preserves_executable_accumulator(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + called = [] + + def original(): + called.append("original") + + def active(): + called.append("active") + + active_weak = weakref.ref(active) + source = GraphDefinition() + node = source.callback(original) + graph = source.instantiate() + graph[node].update(active) + + rejected = GraphDefinition() + rejected.callback(lambda: called.append("rejected")) + rejected.empty() + with pytest.raises(CUDAError): + graph.update(rejected) + + del active, original, node, source, rejected + gc.collect() + assert active_weak() is not None + + stream = init_cuda.create_stream() + graph.launch(stream) + stream.sync() + assert called == ["active"] + + del graph + _wait_until(lambda: active_weak() is None) + + +@pytest.mark.agent_authored(model="gpt-5.6") +def test_inflight_launch_defers_replaced_executable_owners(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + callback_started = threading.Event() + callback_release = threading.Event() + + def blocking_callback(): + callback_started.set() + assert callback_release.wait(timeout=30) + + kernel = compile_common_kernels().get_kernel("add_one") + config = LaunchConfig(grid=1, block=1) + memory_resource = LegacyPinnedMemoryResource() + original = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) + inflight = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) + future = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) + inflight_weak = weak_handle(inflight) + + source = GraphDefinition() + kernel_node = source.callback(blocking_callback).launch(config, kernel, original) + graph = source.instantiate() + graph[kernel_node].update(config=config, kernel=kernel, args=(inflight,)) + del inflight + gc.collect() + assert inflight_weak + + replacement = GraphDefinition() + replacement.callback(lambda: None).launch(config, kernel, future) + stream = init_cuda.create_stream() + graph.launch(stream) + assert callback_started.wait(timeout=5) + + try: + graph.update(replacement) + gc.collect() + assert inflight_weak + finally: + callback_release.set() + stream.sync() + + _wait_until(lambda: not inflight_weak) + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_sequential_executable_updates_accumulate_owners(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + called = [] + + def original(): + called.append("original") + + def first(): + called.append("first") + + def second(): + called.append("second") + + first_weak = weakref.ref(first) + second_weak = weakref.ref(second) + source = GraphDefinition() + node = source.callback(original) + graph = source.instantiate() + + graph[node].update(first) + graph[node].update(second) + + # CUDA cannot detach user objects from an executable graph, so the + # superseded owner stays reachable for as long as the executable lives. + del first, second, original + gc.collect() + assert first_weak() is not None + assert second_weak() is not None + + stream = init_cuda.create_stream() + graph.launch(stream) + stream.sync() + assert called == ["second"] + + del node, source, graph + _wait_until(lambda: first_weak() is None and second_weak() is None) + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_child_graph_update_transfers_source_owners_to_executable(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + called = [] + + def original(): + called.append("original") + + def replacement(): + called.append("replacement") + + original_child = GraphDefinition() + original_child.callback(original) + source = GraphDefinition() + node = source.embed(original_child) + graph = source.instantiate() + + replacement_child = GraphDefinition() + replacement_child.callback(replacement) + graph[node].update(replacement_child) + + replacement_weak = weakref.ref(replacement) + child_weak = weak_handle(replacement_child) + + # A child-graph update is the one executable update that attaches no owner + # of its own. It is safe because CUDA clones the replacement graph's user + # object references into the executable, so the callback must outlive the + # definition that supplied it. + del replacement_child, replacement + _wait_until(lambda: not child_weak) + assert replacement_weak() is not None + + stream = init_cuda.create_stream() + graph.launch(stream) + stream.sync() + assert called == ["replacement"] + + del graph + _wait_until(lambda: replacement_weak() is None) + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_closing_executable_during_launch_defers_owner_release(init_cuda): + if driver_version() < (12, 2, 0): + pytest.skip("individual graph node updates require CUDA 12.2+") + + callback_started = threading.Event() + callback_release = threading.Event() + + def blocking_callback(): + callback_started.set() + assert callback_release.wait(timeout=30) + + kernel = compile_common_kernels().get_kernel("add_one") + config = LaunchConfig(grid=1, block=1) + memory_resource = LegacyPinnedMemoryResource() + original = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) + inflight = memory_resource.allocate(ctypes.sizeof(ctypes.c_int)) + inflight_weak = weak_handle(inflight) + + source = GraphDefinition() + kernel_node = source.callback(blocking_callback).launch(config, kernel, original) + graph = source.instantiate() + graph[kernel_node].update(config=config, kernel=kernel, args=(inflight,)) + del inflight + gc.collect() + assert inflight_weak + + stream = init_cuda.create_stream() + graph.launch(stream) + assert callback_started.wait(timeout=5) + + try: + # The launch still writes through the buffer the update attached, so + # closing the executable must not retire the accumulator yet. + graph.close() + gc.collect() + assert inflight_weak + finally: + callback_release.set() + stream.sync() + + _wait_until(lambda: not inflight_weak) From 172282492e7b80fdddee006c1e22295f159f94f9 Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Thu, 6 Aug 2026 08:18:47 -0700 Subject: [PATCH 32/50] Add check and agent guidance about uncapped mempools (#2514) * Add check and agent guidance about uncapped mempools * Address review: move mempool check to pre-commit, share POOL_SIZE Review feedback on #2514: - Move the uncapped-pool check out of the live test suite into a check-mempool-hygiene pre-commit hook. The rule is about source text and needs no GPU, so a hook catches it earlier and for free. Its tests move to ci/tools/tests, alongside the other check scripts'. - Add helpers/constants.py and route the eleven ad-hoc POOL_SIZE definitions through it. - Qualify "device memory" as installed/physical where the doc explains what an uncapped pool reserves. --- .pre-commit-config.yaml | 6 + ci/tools/check_mempool_hygiene.py | 113 ++++++++++++++++++ ci/tools/tests/test_check_mempool_hygiene.py | 96 +++++++++++++++ cuda_core/tests/AGENTS.md | 67 +++++++++++ cuda_core/tests/conftest.py | 2 +- cuda_core/tests/helpers/constants.py | 14 +++ cuda_core/tests/memory_ipc/test_errors.py | 2 +- .../memory_ipc/test_ipc_duplicate_import.py | 1 - .../tests/memory_ipc/test_peer_access.py | 2 +- .../tests/memory_ipc/test_send_buffers.py | 2 +- cuda_core/tests/memory_ipc/test_serialize.py | 1 - cuda_core/tests/memory_ipc/test_workerpool.py | 2 +- cuda_core/tests/test_memory.py | 6 +- cuda_core/tests/test_memory_peer_access.py | 11 +- .../tests/test_multiprocessing_warning.py | 10 +- cuda_core/tests/test_object_protocols.py | 3 +- 16 files changed, 315 insertions(+), 23 deletions(-) create mode 100644 ci/tools/check_mempool_hygiene.py create mode 100644 ci/tools/tests/test_check_mempool_hygiene.py create mode 100644 cuda_core/tests/AGENTS.md create mode 100644 cuda_core/tests/helpers/constants.py diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d677b7ea7fe..30faa009fc2 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -58,6 +58,12 @@ repos: files: '^(ci/versions\.yml|cuda_bindings/pixi\.toml|cuda_core/pixi\.toml)$' pass_filenames: false + - id: check-mempool-hygiene + name: Check tests do not create uncapped memory pools + entry: python ./ci/tools/check_mempool_hygiene.py + language: python + files: '^cuda_core/tests/.*\.py$' + - id: no-markdown-in-docs-source name: Prevent markdown files in docs/source directories entry: bash -c diff --git a/ci/tools/check_mempool_hygiene.py b/ci/tools/check_mempool_hygiene.py new file mode 100644 index 00000000000..b200aba1ebb --- /dev/null +++ b/ci/tools/check_mempool_hygiene.py @@ -0,0 +1,113 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Check that tests do not create uncapped CUDA memory pools. + +A pool created without ``max_size`` reserves an address-space window sized from +installed device memory rather than from what the test allocates, and the whole +cuda_core suite shares one process. Enough of those reservations exhaust the +address space, after which the rest of the session fails with +CUDA_ERROR_OUT_OF_MEMORY on a device with free physical memory. + +See cuda_core/tests/AGENTS.md for the rule this enforces. +""" + +from __future__ import annotations + +import argparse +import ast +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +DEFAULT_TREE = ROOT / "cuda_core" / "tests" + +# Managed pools cannot be right-sized: cuMemPoolCreate requires maxSize == 0 for +# managed pools, so ManagedMemoryResourceOptions has no max_size to set. +CAPPABLE_OPTIONS = frozenset({"DeviceMemoryResourceOptions", "PinnedMemoryResourceOptions"}) +CAPPABLE_RESOURCES = frozenset({"DeviceMemoryResource", "PinnedMemoryResource"}) + +OPT_OUT_MARKER = "uncapped-pool-ok" + + +def _callee_name(node: ast.Call) -> str: + func = node.func + if isinstance(func, ast.Attribute): + return func.attr + if isinstance(func, ast.Name): + return func.id + return "" + + +def _is_capped(node: ast.Call) -> bool: + # ``**kwargs`` (arg is None) may carry max_size; do not guess. + return any(kw.arg is None or kw.arg == "max_size" for kw in node.keywords) + + +def _dict_is_capped(node: ast.Dict) -> bool: + for key in node.keys: + if key is None: # ``**other`` inside the literal + return True + if isinstance(key, ast.Constant) and key.value == "max_size": + return True + return False + + +def _opted_out(lines: list[str], node: ast.AST) -> bool: + """True if the call, or the line above it, carries the opt-out marker.""" + start = max(node.lineno - 2, 0) # -1 for 0-based, -1 more for a preceding comment + end = getattr(node, "end_lineno", node.lineno) + return any(OPT_OUT_MARKER in line for line in lines[start:end]) + + +def violations_in(path: Path) -> list[str]: + """Return one message per uncapped pool construction in ``path``.""" + source = path.read_text(encoding="utf-8") + lines = source.splitlines() + found = [] + for node in ast.walk(ast.parse(source, filename=str(path))): + if not isinstance(node, ast.Call): + continue + name = _callee_name(node) + if name in CAPPABLE_OPTIONS: + uncapped = not _is_capped(node) + elif name in CAPPABLE_RESOURCES: + # The options may also be given as a dict literal. + dicts = [arg for arg in [*node.args, *(kw.value for kw in node.keywords)] if isinstance(arg, ast.Dict)] + uncapped = any(not _dict_is_capped(d) for d in dicts) + else: + continue + if uncapped and not _opted_out(lines, node): + found.append(f"{path.as_posix()}:{node.lineno}: {name} without max_size") + return found + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "paths", + nargs="*", + type=Path, + help=f"Files to check. Defaults to every .py under {DEFAULT_TREE.relative_to(ROOT).as_posix()}.", + ) + args = parser.parse_args(argv) + + paths = args.paths or sorted(DEFAULT_TREE.rglob("*.py")) + violations = sorted(v for path in paths if path.suffix == ".py" for v in violations_in(path)) + if not violations: + return 0 + + print("error: memory pools created by tests must set max_size:", file=sys.stderr) + for violation in violations: + print(f" - {violation}", file=sys.stderr) + print( + f"Use the suite-wide POOL_SIZE from cuda_core/tests/helpers/constants.py, or annotate a\n" + f"deliberate exception with a '# {OPT_OUT_MARKER}: ' comment.\n" + f"See cuda_core/tests/AGENTS.md.", + file=sys.stderr, + ) + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/ci/tools/tests/test_check_mempool_hygiene.py b/ci/tools/tests/test_check_mempool_hygiene.py new file mode 100644 index 00000000000..5ff3562059b --- /dev/null +++ b/ci/tools/tests/test_check_mempool_hygiene.py @@ -0,0 +1,96 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import os +import sys + +import pytest + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) +from check_mempool_hygiene import DEFAULT_TREE, main, violations_in + + +def write(tmp_path, source): + path = tmp_path / "test_sample.py" + path.write_text(source, encoding="utf-8") + return path + + +UNCAPPED = [ + pytest.param("DeviceMemoryResource(dev, DeviceMemoryResourceOptions(ipc_enabled=True))", id="options-kwarg"), + pytest.param("PinnedMemoryResource(PinnedMemoryResourceOptions())", id="options-empty"), + pytest.param('DeviceMemoryResource(dev, {"ipc_enabled": True})', id="options-dict"), +] + +CAPPED = [ + pytest.param("DeviceMemoryResource(dev, DeviceMemoryResourceOptions(max_size=POOL_SIZE))", id="capped-kwarg"), + pytest.param('DeviceMemoryResource(dev, {"max_size": POOL_SIZE})', id="capped-dict"), + pytest.param("DeviceMemoryResource(dev, DeviceMemoryResourceOptions(**opts))", id="opaque-kwargs"), + # No options at all wraps the device's default pool and reserves nothing, so + # capping it would convert a free wrapper into a new pool. + pytest.param("DeviceMemoryResource(dev)", id="default-pool-wrapper"), + # cuMemPoolCreate requires maxSize == 0 for managed pools, so these have no + # max_size to set. + pytest.param("ManagedMemoryResource(ManagedMemoryResourceOptions(preferred_location=0))", id="managed-exempt"), +] + + +@pytest.mark.agent_authored(model="claude-opus-5") +@pytest.mark.parametrize("source", UNCAPPED) +def test_uncapped_pool_is_reported(tmp_path, source): + assert violations_in(write(tmp_path, source)) + + +@pytest.mark.agent_authored(model="claude-opus-5") +@pytest.mark.parametrize("source", CAPPED) +def test_acceptable_construction_is_not_reported(tmp_path, source): + assert violations_in(write(tmp_path, source)) == [] + + +@pytest.mark.agent_authored(model="claude-opus-5") +@pytest.mark.parametrize("comment_line", [0, 1], ids=["marker-above", "marker-inline"]) +def test_marker_opts_a_call_out(tmp_path, comment_line): + # The escape hatch exists mainly for pytest.raises cases, where validation + # rejects the arguments before any pool is created. + call = "PinnedMemoryResource(PinnedMemoryResourceOptions())" + marker = "# uncapped-pool-ok: raises before the pool is created" + source = f"{marker}\n{call}" if comment_line == 0 else f"{call} {marker}" + + assert violations_in(write(tmp_path, source)) == [] + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_reported_message_names_file_line_and_symbol(tmp_path): + path = write(tmp_path, "x = 1\nDeviceMemoryResource(dev, DeviceMemoryResourceOptions())\n") + + (violation,) = violations_in(path) + + assert violation.startswith(path.as_posix()) + assert ":2:" in violation + assert "DeviceMemoryResourceOptions without max_size" in violation + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_main_reports_failure_for_the_files_it_is_given(tmp_path, capsys): + path = write(tmp_path, "DeviceMemoryResource(dev, DeviceMemoryResourceOptions())") + + assert main([str(path)]) == 1 + assert "must set max_size" in capsys.readouterr().err + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_main_ignores_non_python_files(tmp_path): + unrelated = tmp_path / "notes.txt" + unrelated.write_text("DeviceMemoryResourceOptions()", encoding="utf-8") + + assert main([str(unrelated)]) == 0 + + +@pytest.mark.agent_authored(model="claude-opus-5") +def test_the_live_test_suite_is_clean(): + # Without a default the hook would only ever see changed files, so a + # violation could ride in on a rename or a merge. + assert DEFAULT_TREE.is_dir() + assert main([]) == 0 diff --git a/cuda_core/tests/AGENTS.md b/cuda_core/tests/AGENTS.md new file mode 100644 index 00000000000..39472d745b5 --- /dev/null +++ b/cuda_core/tests/AGENTS.md @@ -0,0 +1,67 @@ +# cuda.core test suite + +Package-wide conventions live in `../AGENTS.md`; repository-wide ones in +`../../AGENTS.md`. This file covers conventions specific to the tests. + +## Never create an uncapped memory pool + +A memory pool created without `max_size` reserves virtual address space similar +in size to the installed physical device memory regardless of what the test +actually allocates. The reservation is charged to the process address space +even though it is not backed by physical memory, and it is not returned until +the pool is destroyed *and* the stream-ordered frees of its outstanding +allocations retire. The whole suite shares one process and one device, so these +reservations accumulate across tests. + +When a test needs its own pool, use the suite-wide cap from +`helpers/constants.py`: + +```python +from helpers.constants import POOL_SIZE + +mr = DeviceMemoryResource(dev, DeviceMemoryResourceOptions(max_size=POOL_SIZE)) +``` + +Use a larger value only if a test genuinely requires it, and prefer adding a +shared constant to `helpers/constants.py` over redefining one per module. + +### Passing no options is different from passing empty options + +`DeviceMemoryResource(dev)` with no options does **not** create a pool. It +wraps the device's existing default mempool (`_mempool_owned` is false) and +costs no additional address space. Passing *any* options object creates a new +owned pool, and a new pool without `max_size` is uncapped: + +```python +DeviceMemoryResource(dev) # wraps default pool, free +DeviceMemoryResource(dev, DeviceMemoryResourceOptions()) # NEW uncapped pool, expensive +DeviceMemoryResource(dev, {"ipc_enabled": True}) # NEW uncapped pool, expensive +``` + +Do not add `max_size` to a call that currently passes no options: that +converts a free default-pool wrapper into a new pool and makes things worse. + +### Managed pools are exempt + +`cuMemPoolCreate` requires `CUmemPoolProps.maxSize` to be zero for managed +pools, so `ManagedMemoryResourceOptions` has no `max_size` option. Managed +pools cannot be right-sized and are not checked. + +### Document exemptions + +When a call is deliberately exempt -- most often because it sits inside +`pytest.raises` and no pool is ever created -- annotate it: + +```python +with pytest.raises(RuntimeError, match="IPC is not available"): + # uncapped-pool-ok: raises before the pool is created + DeviceMemoryResource(mempool_device, DeviceMemoryResourceOptions(ipc_enabled=True)) +``` + +## Release resources at test boundaries + +The `_init_cuda_context` fixture in `conftest.py` runs `gc.collect()` followed +by `cuCtxSynchronize()` before popping the context. Tests should not rely on +that as a substitute for cleaning up explicitly: prefer context managers for +resources whose lifetime fits a single scope, and keep pool lifetimes inside +the test that creates them. diff --git a/cuda_core/tests/conftest.py b/cuda_core/tests/conftest.py index e012e349d27..dfe97b265eb 100644 --- a/cuda_core/tests/conftest.py +++ b/cuda_core/tests/conftest.py @@ -31,6 +31,7 @@ from cuda_python_test_helpers.marks import skipif_need_cuda_headers # noqa: F401 (re-exported for tests) from cuda_python_test_helpers.mempool import xfail_if_mempool_oom +from helpers.constants import POOL_SIZE import cuda.core from cuda.bindings import driver @@ -316,7 +317,6 @@ def ipc_device(init_cuda): ) def ipc_memory_resource(request, ipc_device): """Provides IPC-enabled memory resource (either Device or Pinned).""" - POOL_SIZE = 2097152 mr_type = request.param if mr_type == "device": diff --git a/cuda_core/tests/helpers/constants.py b/cuda_core/tests/helpers/constants.py new file mode 100644 index 00000000000..f4ea61b1938 --- /dev/null +++ b/cuda_core/tests/helpers/constants.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Constants shared across the cuda_core test suite.""" + +# Cap for memory pools created by tests. A pool created without an explicit +# max_size instead reserves a system-dependent window that scales with +# installed device memory -- hundreds of GiB on large-memory GPUs. The +# per-process virtual address budget is bounded (~1 TB on Windows MCDM), and a +# reservation is not returned until the pool is torn down and its +# stream-ordered frees retire, so oversized windows accumulate across a session +# and eventually starve later pool creations with CUDA_ERROR_OUT_OF_MEMORY +# (issue #2381). See AGENTS.md in the tests directory. +POOL_SIZE = 2097152 # 2 MiB diff --git a/cuda_core/tests/memory_ipc/test_errors.py b/cuda_core/tests/memory_ipc/test_errors.py index 40162fab01d..0aac9f9a297 100644 --- a/cuda_core/tests/memory_ipc/test_errors.py +++ b/cuda_core/tests/memory_ipc/test_errors.py @@ -7,6 +7,7 @@ import pytest from helpers.child_processes import child_timeout_sec, kill_subprocesses +from helpers.constants import POOL_SIZE from cuda.core import Buffer, Device, DeviceMemoryResource, DeviceMemoryResourceOptions from cuda.core._memory._ipc import IPCBufferDescriptor @@ -14,7 +15,6 @@ CHILD_TIMEOUT_SEC = child_timeout_sec() NBYTES = 64 -POOL_SIZE = 2097152 # these tests spawn new processes and files which fails for very many threads diff --git a/cuda_core/tests/memory_ipc/test_ipc_duplicate_import.py b/cuda_core/tests/memory_ipc/test_ipc_duplicate_import.py index eaa6ddec92f..dc3f5e57c33 100644 --- a/cuda_core/tests/memory_ipc/test_ipc_duplicate_import.py +++ b/cuda_core/tests/memory_ipc/test_ipc_duplicate_import.py @@ -20,7 +20,6 @@ CHILD_TIMEOUT_SEC = child_timeout_sec() NBYTES = 64 -POOL_SIZE = 2097152 ENABLE_LOGGING = False # Set True for test debugging and development diff --git a/cuda_core/tests/memory_ipc/test_peer_access.py b/cuda_core/tests/memory_ipc/test_peer_access.py index ac7f71a88e9..4dc04a8bd0b 100644 --- a/cuda_core/tests/memory_ipc/test_peer_access.py +++ b/cuda_core/tests/memory_ipc/test_peer_access.py @@ -6,13 +6,13 @@ import pytest from helpers.buffers import PatternGen from helpers.child_processes import child_timeout_sec, kill_subprocesses +from helpers.constants import POOL_SIZE from cuda.core import Device, DeviceMemoryResource, DeviceMemoryResourceOptions from cuda.core._utils.cuda_utils import CUDAError CHILD_TIMEOUT_SEC = child_timeout_sec() NBYTES = 64 -POOL_SIZE = 2097152 # these tests spawn new processes and files which fails for very many threads pytestmark = pytest.mark.parallel_threads_limit(4) diff --git a/cuda_core/tests/memory_ipc/test_send_buffers.py b/cuda_core/tests/memory_ipc/test_send_buffers.py index 59216cd9cce..efa4d8b2abc 100644 --- a/cuda_core/tests/memory_ipc/test_send_buffers.py +++ b/cuda_core/tests/memory_ipc/test_send_buffers.py @@ -7,6 +7,7 @@ import pytest from helpers.buffers import PatternGen from helpers.child_processes import child_timeout_sec, kill_subprocesses +from helpers.constants import POOL_SIZE from cuda.core import Device, DeviceMemoryResource, DeviceMemoryResourceOptions @@ -14,7 +15,6 @@ NBYTES = 64 NMRS = 3 NTASKS = 7 -POOL_SIZE = 2097152 # these tests spawn new processes and files which fails for very many threads pytestmark = pytest.mark.parallel_threads_limit(4) diff --git a/cuda_core/tests/memory_ipc/test_serialize.py b/cuda_core/tests/memory_ipc/test_serialize.py index 4289de4b5a9..22596582c49 100644 --- a/cuda_core/tests/memory_ipc/test_serialize.py +++ b/cuda_core/tests/memory_ipc/test_serialize.py @@ -13,7 +13,6 @@ CHILD_TIMEOUT_SEC = child_timeout_sec() NBYTES = 64 -POOL_SIZE = 2097152 # these tests spawn new processes and files which fails for very many threads pytestmark = pytest.mark.parallel_threads_limit(4) diff --git a/cuda_core/tests/memory_ipc/test_workerpool.py b/cuda_core/tests/memory_ipc/test_workerpool.py index 358c16fd7bf..e358c043b00 100644 --- a/cuda_core/tests/memory_ipc/test_workerpool.py +++ b/cuda_core/tests/memory_ipc/test_workerpool.py @@ -7,6 +7,7 @@ import pytest from helpers.buffers import PatternGen +from helpers.constants import POOL_SIZE from cuda.core import Buffer, Device, DeviceMemoryResource, DeviceMemoryResourceOptions @@ -14,7 +15,6 @@ NWORKERS = 2 NMRS = 3 NTASKS = 20 -POOL_SIZE = 2097152 # these tests spawn new processes and files which fails for very many threads pytestmark = pytest.mark.parallel_threads_limit(4) diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index 98baa521ef2..6af4d025b03 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -22,6 +22,7 @@ ) from helpers import supports_ipc_mempool from helpers.buffers import DummyDeviceMemoryResource, DummyUnifiedMemoryResource, TrackingMR +from helpers.constants import POOL_SIZE from cuda.core import ( Buffer, @@ -55,8 +56,6 @@ from cuda.core.utils import StridedMemoryView from cuda_python_test_helpers import IS_WINDOWS -POOL_SIZE = 2097152 # 2MB size - def _allocate_pinned_buffer_or_xfail(mr, size, *, device): try: @@ -1519,9 +1518,11 @@ def test_pinned_mr_numa_id_negative_error(init_cuda): skip_if_pinned_memory_unsupported(device) with pytest.raises(ValueError, match="numa_id must be >= 0"): + # uncapped-pool-ok: numa_id is validated before the pool is created PinnedMemoryResource(PinnedMemoryResourceOptions(numa_id=-1)) with pytest.raises(ValueError, match="numa_id must be >= 0"): + # uncapped-pool-ok: numa_id is validated before the pool is created PinnedMemoryResource(PinnedMemoryResourceOptions(numa_id=-42)) @@ -1971,4 +1972,5 @@ def test_dmr_ipc_enabled_unsupported_raises(mempool_device): if not IS_WINDOWS: pytest.skip("memory IPC is supported on this platform; unsupported-raise path is Windows-only") with pytest.raises(RuntimeError, match="IPC is not available"): + # uncapped-pool-ok: IPC support is checked before the pool is created DeviceMemoryResource(mempool_device, DeviceMemoryResourceOptions(ipc_enabled=True)) diff --git a/cuda_core/tests/test_memory_peer_access.py b/cuda_core/tests/test_memory_peer_access.py index 2cbfbbd302f..4763b761ad4 100644 --- a/cuda_core/tests/test_memory_peer_access.py +++ b/cuda_core/tests/test_memory_peer_access.py @@ -4,6 +4,7 @@ import pytest from helpers.buffers import PatternGen, compare_buffer_to_constant, make_scratch_buffer from helpers.collection_interface_testers import assert_single_member_mutable_set_interface +from helpers.constants import POOL_SIZE from cuda.core import Device, DeviceMemoryResource, DeviceMemoryResourceOptions, system from cuda.core._memory import _peer_access_utils @@ -11,14 +12,8 @@ from cuda.core._utils.cuda_utils import CUDAError NBYTES = 1024 -# Every owned pool below holds at most NBYTES, but a pool created without an -# explicit max_size reserves a system-dependent window that scales with device -# memory -- hundreds of GiB on large-memory GPUs. The per-process virtual -# address budget is bounded (~1 TB on Windows MCDM), and reservations are not -# returned until a pool is torn down and its stream-ordered frees retire, so -# oversized windows accumulate across a session and eventually starve later -# pool creations with CUDA_ERROR_OUT_OF_MEMORY (issue #2381). Cap them. -POOL_SIZE = 2097152 # 2MB size +# Every owned pool below holds at most NBYTES, so they are all capped at the +# suite-wide POOL_SIZE; see helpers/constants.py for why that matters. pytestmark = pytest.mark.thread_unsafe(reason="peer access tests mutate process-global CUDA memory-pool access state") diff --git a/cuda_core/tests/test_multiprocessing_warning.py b/cuda_core/tests/test_multiprocessing_warning.py index 0f96e0abfbc..1ddb53edb0f 100644 --- a/cuda_core/tests/test_multiprocessing_warning.py +++ b/cuda_core/tests/test_multiprocessing_warning.py @@ -12,6 +12,8 @@ import warnings from unittest.mock import patch +from helpers.constants import POOL_SIZE + from cuda.core import DeviceMemoryResource, DeviceMemoryResourceOptions, EventOptions from cuda.core._event import _reduce_event from cuda.core._memory._device_memory_resource import _deep_reduce_device_memory_resource @@ -23,7 +25,7 @@ def test_warn_on_fork_method_device_memory_resource(ipc_device): """Test that warning is emitted when DeviceMemoryResource is pickled with fork method.""" device = ipc_device device.set_current() - options = DeviceMemoryResourceOptions(max_size=2097152, ipc_enabled=True) + options = DeviceMemoryResourceOptions(max_size=POOL_SIZE, ipc_enabled=True) mr = DeviceMemoryResource(device, options=options) with patch("multiprocessing.get_start_method", return_value="fork"), warnings.catch_warnings(record=True) as w: @@ -50,7 +52,7 @@ def test_warn_on_fork_method_allocation_handle(ipc_device): """Test that warning is emitted when IPCAllocationHandle is pickled with fork method.""" device = ipc_device device.set_current() - options = DeviceMemoryResourceOptions(max_size=2097152, ipc_enabled=True) + options = DeviceMemoryResourceOptions(max_size=POOL_SIZE, ipc_enabled=True) mr = DeviceMemoryResource(device, options=options) alloc_handle = mr.allocation_handle @@ -102,7 +104,7 @@ def test_no_warning_with_spawn_method(ipc_device): """Test that no warning is emitted when start method is 'spawn'.""" device = ipc_device device.set_current() - options = DeviceMemoryResourceOptions(max_size=2097152, ipc_enabled=True) + options = DeviceMemoryResourceOptions(max_size=POOL_SIZE, ipc_enabled=True) mr = DeviceMemoryResource(device, options=options) with patch("multiprocessing.get_start_method", return_value="spawn"), warnings.catch_warnings(record=True) as w: @@ -125,7 +127,7 @@ def test_warning_emitted_only_once(ipc_device): """Test that warning is only emitted once even when multiple objects are pickled.""" device = ipc_device device.set_current() - options = DeviceMemoryResourceOptions(max_size=2097152, ipc_enabled=True) + options = DeviceMemoryResourceOptions(max_size=POOL_SIZE, ipc_enabled=True) mr1 = DeviceMemoryResource(device, options=options) mr2 = DeviceMemoryResource(device, options=options) diff --git a/cuda_core/tests/test_object_protocols.py b/cuda_core/tests/test_object_protocols.py index f843f451683..f7f4c854313 100644 --- a/cuda_core/tests/test_object_protocols.py +++ b/cuda_core/tests/test_object_protocols.py @@ -14,6 +14,7 @@ import pytest from conftest import xfail_on_graph_mempool_oom +from helpers.constants import POOL_SIZE from helpers.graph_kernels import compile_common_kernels from helpers.misc import try_create_condition @@ -224,8 +225,6 @@ def sample_kernel_alt(sample_object_code_alt): # Fixtures - IPC samples (for pickle tests) # ============================================================================= -POOL_SIZE = 2097152 - @pytest.fixture def sample_ipc_buffer_descriptor(ipc_device): From e9634793d1d881f4079ed9f9e902fde8982605ff Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Thu, 6 Aug 2026 09:09:38 -0700 Subject: [PATCH 33/50] build: report cuda-bindings provenance in PEP 517 builds (#2520) Resolve the CUDA path before importing cuda.bindings so the existing pathfinder import repairs PEP 517 namespace shadowing first. Reuse the resolved path for the CUDA include directory. --- cuda_core/build_hooks.py | 5 ++++- cuda_core/tests/test_build_hooks.py | 30 +++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+), 1 deletion(-) diff --git a/cuda_core/build_hooks.py b/cuda_core/build_hooks.py index 05cc9267726..626d50355ab 100644 --- a/cuda_core/build_hooks.py +++ b/cuda_core/build_hooks.py @@ -133,6 +133,9 @@ def _build_cuda_core(debug=False): # This function populates "_extensions". global _extensions + # Resolve CUDA first so the pathfinder import repairs PEP 517 namespace shadowing before importing bindings. + cuda_path = _get_cuda_path() + # Add cuda-bindings to sys.path so Cython can find .pxd files # This is needed for editable installs where meta path finders don't work for Cython # We need to add the directory containing the 'cuda' package so Cython can resolve @@ -178,7 +181,7 @@ def get_sources(mod_name): return sources - all_include_dirs = [os.path.join(_get_cuda_path(), "include")] + all_include_dirs = [os.path.join(cuda_path, "include")] extra_compile_args = [] extra_link_args = [] extra_cythonize_kwargs = {} diff --git a/cuda_core/tests/test_build_hooks.py b/cuda_core/tests/test_build_hooks.py index 121ed1be053..c08ad4cd3c5 100644 --- a/cuda_core/tests/test_build_hooks.py +++ b/cuda_core/tests/test_build_hooks.py @@ -16,6 +16,7 @@ These tests require Cython to be installed (build_hooks.py imports it). """ +import builtins import importlib.util import os import tempfile @@ -50,6 +51,35 @@ def _load_build_hooks(): build_hooks = _load_build_hooks() +@pytest.mark.agent_authored(model="gpt-5.6") +def test_cuda_path_is_resolved_before_importing_bindings(monkeypatch): + """PEP 517 namespace repair runs before cuda.bindings is imported.""" + events = [] + + class StopBuildError(Exception): + pass + + def get_cuda_path(): + events.append("cuda-path") + return "/cuda" + + original_import = builtins.__import__ + + def stop_at_bindings_import(name, *args, **kwargs): + if name == "cuda.bindings": + events.append("cuda-bindings") + raise StopBuildError + return original_import(name, *args, **kwargs) + + monkeypatch.setattr(build_hooks, "_get_cuda_path", get_cuda_path) + monkeypatch.setattr(builtins, "__import__", stop_at_bindings_import) + + with pytest.raises(StopBuildError): + build_hooks._build_cuda_core() + + assert events == ["cuda-path", "cuda-bindings"] + + def _check_version_detection( cuda_version, expected_major, *, use_cuda_path=True, use_cuda_home=False, cuda_core_build_major=None ): From 182a7f677d32ea8cc7bc88a74ba07f3251d88a59 Mon Sep 17 00:00:00 2001 From: Michael Wang <13521008+isVoid@users.noreply.github.com> Date: Thu, 6 Aug 2026 12:22:52 -0700 Subject: [PATCH 34/50] Make Windows static library searches architecture-aware (#2491) * Make static library discovery architecture-aware * Use architecture-specific static library paths --------- Co-authored-by: Michael Wang --- .../_static_libs/find_static_lib.py | 32 +++++++++++------ .../docs/source/release/1.6.1-notes.rst | 5 +++ cuda_pathfinder/tests/test_find_static_lib.py | 35 +++++++++++++++++++ 3 files changed, 62 insertions(+), 10 deletions(-) diff --git a/cuda_pathfinder/cuda/pathfinder/_static_libs/find_static_lib.py b/cuda_pathfinder/cuda/pathfinder/_static_libs/find_static_lib.py index 804b1c04be7..ea5a740aec4 100644 --- a/cuda_pathfinder/cuda/pathfinder/_static_libs/find_static_lib.py +++ b/cuda_pathfinder/cuda/pathfinder/_static_libs/find_static_lib.py @@ -9,6 +9,7 @@ from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages from cuda.pathfinder._utils.platform_aware import IS_WINDOWS +from cuda.pathfinder._utils.windows_arch import windows_python_arch class StaticLibNotFoundError(RuntimeError): @@ -32,17 +33,28 @@ class _StaticLibInfo(TypedDict): site_packages_dirs: tuple[str, ...] +def _cudadevrt_info() -> _StaticLibInfo: + if not IS_WINDOWS: + return { + "filename": "libcudadevrt.a", + "ctk_rel_paths": ("lib64", "lib"), + "conda_rel_paths": ("lib",), + "site_packages_dirs": ("nvidia/cu13/lib", "nvidia/cuda_runtime/lib"), + } + + arch_dir = windows_python_arch() + component_wheel_dirs = ("nvidia/cuda_runtime/lib/x64",) if arch_dir == "x64" else () + conda_fallback_dirs = ("lib",) if arch_dir == "x64" else () + return { + "filename": "cudadevrt.lib", + "ctk_rel_paths": (os.path.join("lib", arch_dir),), + "conda_rel_paths": (os.path.join("lib", arch_dir), *conda_fallback_dirs), + "site_packages_dirs": (f"nvidia/cu13/lib/{arch_dir}", *component_wheel_dirs), + } + + _SUPPORTED_STATIC_LIBS_INFO: dict[str, _StaticLibInfo] = { - "cudadevrt": { - "filename": "cudadevrt.lib" if IS_WINDOWS else "libcudadevrt.a", - "ctk_rel_paths": (os.path.join("lib", "x64"),) if IS_WINDOWS else ("lib64", "lib"), - "conda_rel_paths": ((os.path.join("lib", "x64"), "lib") if IS_WINDOWS else ("lib",)), - "site_packages_dirs": ( - ("nvidia/cu13/lib/x64", "nvidia/cuda_runtime/lib/x64") - if IS_WINDOWS - else ("nvidia/cu13/lib", "nvidia/cuda_runtime/lib") - ), - }, + "cudadevrt": _cudadevrt_info(), } SUPPORTED_STATIC_LIBS: tuple[str, ...] = tuple(sorted(_SUPPORTED_STATIC_LIBS_INFO.keys())) diff --git a/cuda_pathfinder/docs/source/release/1.6.1-notes.rst b/cuda_pathfinder/docs/source/release/1.6.1-notes.rst index 29a3106e0f1..919963802ff 100644 --- a/cuda_pathfinder/docs/source/release/1.6.1-notes.rst +++ b/cuda_pathfinder/docs/source/release/1.6.1-notes.rst @@ -24,6 +24,11 @@ Highlights * Add ``UnsupportedArchError`` for unsupported Windows Python platform tags. +* Make Windows static-library discovery architecture-aware. Searches now use + the current Python interpreter architecture to select the matching + ``lib/x64`` or ``lib/arm64`` CUDA Toolkit and wheel directories. CUDA 12 + component-wheel and legacy Conda fallbacks remain x64-only. + Internal maintenance -------------------- diff --git a/cuda_pathfinder/tests/test_find_static_lib.py b/cuda_pathfinder/tests/test_find_static_lib.py index e5560dcabbf..6d29a8def11 100644 --- a/cuda_pathfinder/tests/test_find_static_lib.py +++ b/cuda_pathfinder/tests/test_find_static_lib.py @@ -143,6 +143,41 @@ def test_locate_static_lib_conda_rel_path_fallback(monkeypatch, tmp_path): assert located_lib.found_via == "conda" +@pytest.mark.parametrize( + ("target_arch", "expected_ctk_dirs", "expected_conda_dirs", "expected_site_packages_dirs"), + ( + ( + "x64", + (os.path.join("lib", "x64"),), + (os.path.join("lib", "x64"), "lib"), + ("nvidia/cu13/lib/x64", "nvidia/cuda_runtime/lib/x64"), + ), + ( + "arm64", + (os.path.join("lib", "arm64"),), + (os.path.join("lib", "arm64"),), + ("nvidia/cu13/lib/arm64",), + ), + ), +) +@pytest.mark.agent_authored(model="gpt-5.6") +def test_cudadevrt_windows_paths_follow_python_arch( + monkeypatch, + target_arch, + expected_ctk_dirs, + expected_conda_dirs, + expected_site_packages_dirs, +): + monkeypatch.setattr(find_static_lib_module, "IS_WINDOWS", True) + monkeypatch.setattr(find_static_lib_module, "windows_python_arch", lambda: target_arch) + + info = find_static_lib_module._cudadevrt_info() + + assert info["ctk_rel_paths"] == expected_ctk_dirs + assert info["conda_rel_paths"] == expected_conda_dirs + assert info["site_packages_dirs"] == expected_site_packages_dirs + + @pytest.mark.usefixtures("clear_find_static_lib_cache") def test_find_static_lib_not_found_error_includes_cuda_home_directory_listing(monkeypatch, tmp_path): filename = CUDADEVRT_INFO["filename"] From bf8dc4121668155436cc16993fd8747591879883 Mon Sep 17 00:00:00 2001 From: Jinfeng Li Date: Thu, 6 Aug 2026 15:30:04 -0400 Subject: [PATCH 35/50] cuda.core: add LaunchConfig.programmatic_stream_serialization for programmatic dependent launch (#2456) * feat(cuda.core): expose PDL via LaunchConfig.programmatic_stream_serialization Allow users to set CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION through LaunchConfig, matching the is_cooperative attribute pattern (#1334). * test(cuda.core): verify PDL overlap for primary/secondary launch Add an end-to-end Hopper+ test that launches primary and secondary kernels on the same stream with programmatic_stream_serialization, and asserts overlap only when the PDL attribute is enabled (#1334). * test(cuda.core): simplify PDL secondary kernel and log success Drop unused secondary sync/sleep from the overlap test, clarify the primary clock window comment, and print a short success line for CI. * add pre-commit passed * revise to xfail --- cuda_core/cuda/core/_launch_config.pxd | 1 + cuda_core/cuda/core/_launch_config.pyi | 10 +- cuda_core/cuda/core/_launch_config.pyx | 28 +++++- cuda_core/tests/test_launcher.py | 111 +++++++++++++++++++++++ cuda_core/tests/test_object_protocols.py | 3 +- 5 files changed, 149 insertions(+), 4 deletions(-) diff --git a/cuda_core/cuda/core/_launch_config.pxd b/cuda_core/cuda/core/_launch_config.pxd index 112007b9cfd..892a73f8efc 100644 --- a/cuda_core/cuda/core/_launch_config.pxd +++ b/cuda_core/cuda/core/_launch_config.pxd @@ -15,6 +15,7 @@ cdef class LaunchConfig: public tuple block public int shmem_size public bint is_cooperative + public bint programmatic_stream_serialization vector[cydriver.CUlaunchAttribute] _attrs object __weakref__ diff --git a/cuda_core/cuda/core/_launch_config.pyi b/cuda_core/cuda/core/_launch_config.pyi index bb47f1901a8..579818342fb 100644 --- a/cuda_core/cuda/core/_launch_config.pyi +++ b/cuda_core/cuda/core/_launch_config.pyi @@ -35,9 +35,13 @@ class LaunchConfig: (Default to size 0) is_cooperative : bool, optional Whether this config can be used to launch a cooperative kernel. + programmatic_stream_serialization : bool, optional + Whether to allow programmatic stream serialization (PDL). When True, + the kernel may overlap with a previous kernel in the same stream that + signals completion via programmatic means. """ - def __init__(self, grid: int | tuple[int, ...] | None=None, cluster: int | tuple[int, ...] | None=None, block: int | tuple[int, ...] | None=None, shmem_size: int | None=None, is_cooperative: bool=False) -> None: + def __init__(self, grid: int | tuple[int, ...] | None=None, cluster: int | tuple[int, ...] | None=None, block: int | tuple[int, ...] | None=None, shmem_size: int | None=None, is_cooperative: bool=False, programmatic_stream_serialization: bool=False) -> None: """Initialize LaunchConfig with validation. Parameters @@ -52,6 +56,8 @@ class LaunchConfig: Dynamic shared memory size in bytes (default: 0) is_cooperative : bool, optional Whether to launch as cooperative kernel (default: False) + programmatic_stream_serialization : bool, optional + Whether to allow programmatic stream serialization / PDL (default: False) """ def _identity(self) -> tuple[Any, ...]: @@ -65,7 +71,7 @@ class LaunchConfig: def __hash__(self) -> int: ... -_LAUNCH_CONFIG_ATTRS = ('grid', 'cluster', 'block', 'shmem_size', 'is_cooperative') +_LAUNCH_CONFIG_ATTRS = ('grid', 'cluster', 'block', 'shmem_size', 'is_cooperative', 'programmatic_stream_serialization') __all__ = ['LaunchConfig'] def _to_native_launch_config(config: LaunchConfig) -> object: diff --git a/cuda_core/cuda/core/_launch_config.pyx b/cuda_core/cuda/core/_launch_config.pyx index 44dbe2f1cbf..3a2f36a4dff 100644 --- a/cuda_core/cuda/core/_launch_config.pyx +++ b/cuda_core/cuda/core/_launch_config.pyx @@ -13,7 +13,14 @@ from cuda.core._utils.cuda_utils import ( driver, ) -_LAUNCH_CONFIG_ATTRS = ('grid', 'cluster', 'block', 'shmem_size', 'is_cooperative') +_LAUNCH_CONFIG_ATTRS = ( + 'grid', + 'cluster', + 'block', + 'shmem_size', + 'is_cooperative', + 'programmatic_stream_serialization', +) __all__ = ['LaunchConfig'] @@ -48,6 +55,10 @@ cdef class LaunchConfig: (Default to size 0) is_cooperative : bool, optional Whether this config can be used to launch a cooperative kernel. + programmatic_stream_serialization : bool, optional + Whether to allow programmatic stream serialization (PDL). When True, + the kernel may overlap with a previous kernel in the same stream that + signals completion via programmatic means. """ # TODO: expand LaunchConfig to include other attributes @@ -60,6 +71,7 @@ cdef class LaunchConfig: block: int | tuple[int, ...] | None = None, shmem_size: int | None = None, is_cooperative: bool = False, + programmatic_stream_serialization: bool = False, ) -> None: """Initialize LaunchConfig with validation. @@ -75,6 +87,8 @@ cdef class LaunchConfig: Dynamic shared memory size in bytes (default: 0) is_cooperative : bool, optional Whether to launch as cooperative kernel (default: False) + programmatic_stream_serialization : bool, optional + Whether to allow programmatic stream serialization / PDL (default: False) """ # Convert and validate grid and block dimensions self.grid = cast_to_3_tuple("LaunchConfig.grid", grid) @@ -101,6 +115,7 @@ cdef class LaunchConfig: self.shmem_size = shmem_size self.is_cooperative = is_cooperative + self.programmatic_stream_serialization = programmatic_stream_serialization if self.is_cooperative and not Device().properties.cooperative_launch: raise CUDAError("cooperative kernels are not supported on this device") @@ -149,6 +164,11 @@ cdef class LaunchConfig: attr.value.cooperative = 1 self._attrs.push_back(attr) + if self.programmatic_stream_serialization: + attr.id = cydriver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION + attr.value.programmaticStreamSerializationAllowed = 1 + self._attrs.push_back(attr) + drv_cfg.numAttrs = self._attrs.size() drv_cfg.attrs = self._attrs.data() @@ -204,6 +224,12 @@ cpdef object _to_native_launch_config(LaunchConfig config): attr.value.cooperative = 1 attrs.append(attr) + if config.programmatic_stream_serialization: + attr = driver.CUlaunchAttribute() + attr.id = driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION + attr.value.programmaticStreamSerializationAllowed = 1 + attrs.append(attr) + drv_cfg.numAttrs = len(attrs) drv_cfg.attrs = attrs diff --git a/cuda_core/tests/test_launcher.py b/cuda_core/tests/test_launcher.py index 04fd714aa96..e5cf05b435d 100644 --- a/cuda_core/tests/test_launcher.py +++ b/cuda_core/tests/test_launcher.py @@ -183,6 +183,117 @@ class _FakeDev: assert attr.value.cooperative == 1, f"Expected cooperative=1, got {attr.value.cooperative}" +def test_to_native_launch_config_pdl(): + """LaunchConfig(programmatic_stream_serialization=True) maps to the PDL launch attribute.""" + from cuda.bindings import driver + from cuda.core._launch_config import _to_native_launch_config + + config = LaunchConfig(grid=2, block=4, programmatic_stream_serialization=True) + native = _to_native_launch_config(config) + assert native.gridDimX == 2 + assert native.blockDimX == 4 + assert native.numAttrs == 1 + attr = native.attrs[0] + assert attr.id == driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION, ( + f"Expected CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION, got {attr.id}" + ) + assert attr.value.programmaticStreamSerializationAllowed == 1, ( + f"Expected programmaticStreamSerializationAllowed=1, got {attr.value.programmaticStreamSerializationAllowed}" + ) + + +@skipif_need_cuda_headers +def test_pdl_primary_secondary_overlap_same_stream(): + """Primary + secondary PDL launch on one stream can overlap on Hopper+. + + Secondary is launched with ``programmatic_stream_serialization=True``. After + the primary triggers completion, it spins until it observes a flag written by + the secondary's independent preamble — proving both grids were resident at + once. Without PDL, the secondary cannot start until the primary exits. + + Note concurrency is opportunistic, so a missing overlap execution is reported as + an expected failure. + """ + dev = Device() + if dev.compute_capability < (9, 0): + pytest.skip("Programmatic Dependent Launch requires compute capability >= 9.0") + dev.set_current() + stream = dev.create_stream(options={"nonblocking": True}) + + # clock64 budgets are in GPU cycles; keep the post-trigger window long enough + # for the secondary to boot, but short enough for a unit test. + code = r""" + #include + + extern "C" __global__ void primary_kernel(int* secondary_started, int* overlapped) { + cudaTriggerProgrammaticLaunchCompletion(); + + const long long deadline = clock64() + 100000000LL; // ~50ms @ ~2GHz + if (threadIdx.x == 0 && blockIdx.x == 0) { + while (clock64() < deadline) { + if (atomicAdd(secondary_started, 0) != 0) { + atomicExch(overlapped, 1); + return; + } + __nanosleep(1000); + } + } + } + + extern "C" __global__ void secondary_kernel(int* secondary_started) { + if (threadIdx.x == 0 && blockIdx.x == 0) { + atomicExch(secondary_started, 1); + } + } + """ + + arch = "".join(f"{i}" for i in dev.compute_capability) + pro_opts = ProgramOptions(std="c++17", arch=f"sm_{arch}", include_path=helpers.CUDA_INCLUDE_PATH) + prog = Program(code, code_type="c++", options=pro_opts) + mod = prog.compile("cubin") + primary = mod.get_kernel("primary_kernel") + secondary = mod.get_kernel("secondary_kernel") + + mr = LegacyPinnedMemoryResource() + secondary_started = np.from_dlpack(mr.allocate(4)).view(np.int32) + overlapped = np.from_dlpack(mr.allocate(4)).view(np.int32) + + primary_cfg = LaunchConfig(grid=1, block=1) + secondary_cfg = LaunchConfig(grid=1, block=1, programmatic_stream_serialization=True) + secondary_serial_cfg = LaunchConfig(grid=1, block=1) + + def _run(secondary_launch_cfg: LaunchConfig) -> int: + secondary_started[0] = 0 + overlapped[0] = 0 + launch(stream, primary_cfg, primary, secondary_started.ctypes.data, overlapped.ctypes.data) + launch(stream, secondary_launch_cfg, secondary, secondary_started.ctypes.data) + stream.sync() + return int(overlapped[0]) + + # Without the PDL attribute, same-stream kernels stay serialized. + assert _run(secondary_serial_cfg) == 0, "Expected no overlap when programmatic_stream_serialization is False" + + # PDL overlap is opportunistic; retry a few times on a quiet GPU. + saw_overlap = False + for _ in range(5): + if _run(secondary_cfg) == 1: + saw_overlap = True + break + + if not saw_overlap: + # Overlap is never guaranteed by the driver, so a miss is reported as an + # expected failure rather than turning a busy GPU into a red CI run. + pytest.xfail( + "PDL (Programmatic Dependent Launch) overlap was not observed. " + "If this keeps xfailing in CI, manually re-check on a quiet Hopper+ GPU." + ) + + print( + f"PDL (Programmatic Dependent Launch) overlap verified on {dev.name} compute capability {dev.compute_capability}", + flush=True, + ) + + def test_launch_config_cluster_accepts_hopper_cc(monkeypatch): """LaunchConfig accepts ``cluster`` when the device reports compute capability >= 9.0. Device is mocked so the cluster-cast branch runs on any diff --git a/cuda_core/tests/test_object_protocols.py b/cuda_core/tests/test_object_protocols.py index f7f4c854313..e01f7a86941 100644 --- a/cuda_core/tests/test_object_protocols.py +++ b/cuda_core/tests/test_object_protocols.py @@ -684,7 +684,8 @@ def sample_switch_node_alt(sample_graphdef): ( "sample_launch_config", r"LaunchConfig\(grid=\(\d+, \d+, \d+\), cluster=.+, block=\(\d+, \d+, \d+\), " - r"shmem_size=\d+, is_cooperative=(?:True|False)\)", + r"shmem_size=\d+, is_cooperative=(?:True|False), " + r"programmatic_stream_serialization=(?:True|False)\)", ), ("sample_kernel", r""), # ObjectCode variations (by code_type) From 25062e444d9b1a6f84af41d22f5caeb4eb5a65e9 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Thu, 6 Aug 2026 18:57:34 -0400 Subject: [PATCH 36/50] Remove last remnants of Python 3.9 support (#2394) --- ci/tools/merge_cuda_core_wheels.py | 7 +++---- cuda_core/tests/helpers/__init__.py | 3 +-- cuda_python_test_helpers/pyproject.toml | 4 ++-- 3 files changed, 6 insertions(+), 8 deletions(-) diff --git a/ci/tools/merge_cuda_core_wheels.py b/ci/tools/merge_cuda_core_wheels.py index c66a1bfa2a8..23a8a21289f 100644 --- a/ci/tools/merge_cuda_core_wheels.py +++ b/ci/tools/merge_cuda_core_wheels.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 -# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # # SPDX-License-Identifier: Apache-2.0 @@ -27,10 +27,9 @@ import tempfile import zipfile from pathlib import Path -from typing import List -def run_command(cmd: List[str], cwd: Path | None = None, env: dict = os.environ) -> subprocess.CompletedProcess: +def run_command(cmd: list[str], cwd: Path | None = None, env: dict = os.environ) -> subprocess.CompletedProcess: """Run a command with error handling.""" print(f"Running: {' '.join(cmd)}") if cwd: @@ -78,7 +77,7 @@ def print_wheel_directory_structure(wheel_path: Path, filter_prefix: str = "cuda print(f"Warning: Could not list wheel contents: {e}", file=sys.stderr) -def merge_wheels(wheels: List[Path], output_dir: Path, show_wheel_contents: bool = True) -> Path: +def merge_wheels(wheels: list[Path], output_dir: Path, show_wheel_contents: bool = True) -> Path: """Merge multiple wheels into a single wheel with version-specific binaries.""" print("\n=== Merging wheels ===", file=sys.stderr) print(f"Input wheels: {[w.name for w in wheels]}", file=sys.stderr) diff --git a/cuda_core/tests/helpers/__init__.py b/cuda_core/tests/helpers/__init__.py index 5ce5ab7f05b..2305cfaa1e5 100644 --- a/cuda_core/tests/helpers/__init__.py +++ b/cuda_core/tests/helpers/__init__.py @@ -3,7 +3,6 @@ import functools import os -from typing import Union from cuda.core._utils.cuda_utils import handle_return from cuda.pathfinder import get_cuda_path_or_home @@ -23,7 +22,7 @@ @functools.cache -def supports_ipc_mempool(device_id: Union[int, object]) -> bool: +def supports_ipc_mempool(device_id: int | object) -> bool: """Return True if mempool IPC via POSIX file descriptor is supported. Uses cuDeviceGetAttribute(CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES) diff --git a/cuda_python_test_helpers/pyproject.toml b/cuda_python_test_helpers/pyproject.toml index 85652b61c50..f20720f6158 100644 --- a/cuda_python_test_helpers/pyproject.toml +++ b/cuda_python_test_helpers/pyproject.toml @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 [build-system] @@ -12,7 +12,7 @@ description = "Shared test helpers for CUDA Python projects" readme = {file = "README.md", content-type = "text/markdown"} authors = [{ name = "NVIDIA Corporation" }] license = "Apache-2.0" -requires-python = ">=3.9" +requires-python = ">=3.10" classifiers = [ "Programming Language :: Python :: 3 :: Only", "Operating System :: POSIX :: Linux", From 04f7203b9af46c90d3388f5fe5748220bd09639a Mon Sep 17 00:00:00 2001 From: Shaurya Singh Date: Fri, 7 Aug 2026 07:35:37 -0700 Subject: [PATCH 37/50] Match private extension modules against the in-package path only (#2504) check_cython_abi's private-module filter tested `so_path.parts` on the absolute path, so any ancestor directory starting with an underscore made every module look private. That is the normal layout under manylinux (/opt/_internal/cpython-*/) and in GitHub Actions containers (/__w/), where `generate` then writes zero ABI files and exits 0 -- a green run with no coverage at all. `check`'s new-module scan had no filter, while `generate` skipped private modules. Since `generate` never wrote an .abi.json for them, `check` reported every private module as "New module added" on every run and set has_allowed_changes, so it could not print "No changes found" for a package shipping private submodules (cuda.bindings has _bindings/, _internal/, _lib/). Extract the predicate into iter_public_extension_modules() so both paths use it, and match only on the path relative to the package root. --- toolshed/check_cython_abi.py | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/toolshed/check_cython_abi.py b/toolshed/check_cython_abi.py index 155d9c625f3..b72edf40c5c 100644 --- a/toolshed/check_cython_abi.py +++ b/toolshed/check_cython_abi.py @@ -92,6 +92,21 @@ def is_cython_module(module: object) -> bool: return hasattr(module, "__pyx_capi__") +def iter_public_extension_modules(build_dir: Path): + """Yield the extension modules under `build_dir` that are part of the public ABI. + + Private modules (e.g. cuda/bindings/_internal/utils.so) are skipped. Only the + path *inside* the package is inspected: directories above it routinely start + with an underscore (manylinux installs Python under /opt/_internal, GitHub + Actions containers check out under /__w), and those must not make every + module look private. + """ + for so_path in Path(build_dir).glob(f"**/*{EXT_SUFFIX}"): + if any(part.startswith("_") for part in so_path.relative_to(build_dir).parts): + continue + yield so_path + + ###################################################################################### # STRUCTS @@ -473,7 +488,7 @@ def check(package: str, abi_dir: Path) -> bool: print(f"No module found for {abi_path.relative_to(abi_dir)}") has_errors = True - for so_path in Path(build_dir).glob(f"**/*{EXT_SUFFIX}"): + for so_path in iter_public_extension_modules(build_dir): module = import_from_path(package, build_dir, so_path) if hasattr(module, "__pyx_capi__"): abi_path = so_path_to_abi_path(so_path, build_dir, abi_dir) @@ -498,10 +513,7 @@ def generate(package: str, abi_dir: Path) -> bool: return True build_dir = get_package_path(package) - for so_path in Path(build_dir).glob(f"**/*{EXT_SUFFIX}"): - if any(x.startswith("_") for x in so_path.parts): - # Skip private modules (e.g. _driver.so) since they are not part of the public ABI - continue + for so_path in iter_public_extension_modules(build_dir): try: module = import_from_path(package, build_dir, so_path) except ImportError: From 559db81f8a6e26d92b80ca19b565290aabc03d9a Mon Sep 17 00:00:00 2001 From: Shaurya Singh Date: Fri, 7 Aug 2026 08:08:54 -0700 Subject: [PATCH 38/50] Migrate cuda_pathfinder tests from os.path to pathlib (#2495) Part 4 of the series proposed in #2410. Filesystem predicates and path joining in the pathfinder tests now go through pathlib: os.path.isfile/isdir become Path.is_file()/is_dir(), os.path.basename becomes Path.name, os.path.join becomes Path joining, and the site-packages check uses Path.parts instead of splitting on os.path.sep. site_pkg_rel.replace("/", os.sep) is dropped in test_find_static_lib.py: Path already accepts forward slashes on Windows. Two files are left out on purpose. test_find_nvidia_binaries.py moves with part 3, whose signature changes it depends on. test_search_steps.py is being edited by #2489 (part 1), so converting it here would only create a conflict. Left on the stdlib modules: glob.glob in test_find_nvidia_headers.py, which expands an absolute pattern from the header catalog (Path.glob needs a base dir, and the wildcard is not pinned to the last component); os.pathsep in test_ctk_root_discovery.py, which builds PYTHONPATH, not a path; and os.sep in test_utils_env_vars.py, which builds a trailing separator on purpose. Signed-off-by: LeSingh1 --- cuda_pathfinder/tests/test_ctk_root_discovery.py | 3 ++- cuda_pathfinder/tests/test_driver_lib_loading.py | 3 ++- cuda_pathfinder/tests/test_find_bitcode_lib.py | 8 ++++---- cuda_pathfinder/tests/test_find_nvidia_headers.py | 15 +++++++++------ cuda_pathfinder/tests/test_find_static_lib.py | 10 +++++----- .../tests/test_load_nvidia_dynamic_lib.py | 3 ++- cuda_pathfinder/tests/test_utils_find_sub_dirs.py | 4 ++-- 7 files changed, 26 insertions(+), 20 deletions(-) diff --git a/cuda_pathfinder/tests/test_ctk_root_discovery.py b/cuda_pathfinder/tests/test_ctk_root_discovery.py index b4aa33d6a74..f232afe7719 100644 --- a/cuda_pathfinder/tests/test_ctk_root_discovery.py +++ b/cuda_pathfinder/tests/test_ctk_root_discovery.py @@ -6,6 +6,7 @@ import subprocess import sys import textwrap +from pathlib import Path import pytest @@ -427,7 +428,7 @@ def test_resolve_ctk_root_via_canary_none_when_probe_fails(mocker): def test_resolve_ctk_root_via_canary_none_when_unrecognized(mocker): mocker.patch( f"{_MODULE}._resolve_system_loaded_abs_path_in_subprocess", - return_value=os.path.join(os.sep, "weird", "path", "libcudart.so.13"), + return_value=str(Path(os.sep, "weird", "path", "libcudart.so.13")), ) assert resolve_ctk_root_via_canary("cudart") is None diff --git a/cuda_pathfinder/tests/test_driver_lib_loading.py b/cuda_pathfinder/tests/test_driver_lib_loading.py index 9436736310c..defca06abed 100644 --- a/cuda_pathfinder/tests/test_driver_lib_loading.py +++ b/cuda_pathfinder/tests/test_driver_lib_loading.py @@ -9,6 +9,7 @@ """ import os +from pathlib import Path import pytest from child_load_nvidia_dynamic_lib_helper import ( @@ -157,7 +158,7 @@ def raise_child_process_failed(): abs_path = payload.abs_path assert abs_path is not None info_summary_append(f"abs_path={quote_for_shell(abs_path)}") - assert os.path.isfile(abs_path) + assert Path(abs_path).is_file() def test_real_query_driver_cuda_version(info_summary_append): diff --git a/cuda_pathfinder/tests/test_find_bitcode_lib.py b/cuda_pathfinder/tests/test_find_bitcode_lib.py index 659b068f0ff..6b5f2de49eb 100644 --- a/cuda_pathfinder/tests/test_find_bitcode_lib.py +++ b/cuda_pathfinder/tests/test_find_bitcode_lib.py @@ -66,7 +66,7 @@ def _located_bitcode_lib_asserts(located_bitcode_lib): assert isinstance(located_bitcode_lib.filename, str) assert isinstance(located_bitcode_lib.found_via, str) assert located_bitcode_lib.found_via in ("site-packages", "conda", "CUDA_PATH") - assert os.path.isfile(located_bitcode_lib.abs_path) + assert Path(located_bitcode_lib.abs_path).is_file() @pytest.mark.usefixtures("clear_find_bitcode_lib_cache") @@ -83,10 +83,10 @@ def test_locate_bitcode_lib(info_summary_append, libname): info_summary_append(f"{lib_path=!r}") _located_bitcode_lib_asserts(located_lib) - assert os.path.isfile(lib_path) + assert Path(lib_path).is_file() assert lib_path == located_lib.abs_path expected_filename = located_lib.filename - assert os.path.basename(lib_path) == expected_filename + assert Path(lib_path).name == expected_filename @pytest.mark.usefixtures("clear_find_bitcode_lib_cache") @@ -156,7 +156,7 @@ def test_find_bitcode_lib_not_found_error_includes_cuda_home_directory_listing(m find_bitcode_lib("device") message = str(exc_info.value) - expected_missing_file = os.path.join(str(lib_dir), _bitcode_lib_filename("device")) + expected_missing_file = lib_dir / _bitcode_lib_filename("device") assert f"No such file: {expected_missing_file}" in message assert f'listdir("{lib_dir}"):' in message assert "README.txt" in message diff --git a/cuda_pathfinder/tests/test_find_nvidia_headers.py b/cuda_pathfinder/tests/test_find_nvidia_headers.py index 20190725884..3e045dae265 100644 --- a/cuda_pathfinder/tests/test_find_nvidia_headers.py +++ b/cuda_pathfinder/tests/test_find_nvidia_headers.py @@ -138,12 +138,12 @@ def test_locate_non_ctk_headers(info_summary_append, libname): info_summary_append(f"{hdr_dir=!r}") if hdr_dir: _located_hdr_dir_asserts(located_hdr_dir) - assert os.path.isdir(hdr_dir) - assert os.path.isfile(os.path.join(hdr_dir, SUPPORTED_HEADERS_NON_CTK[libname])) + hdr_dir_path = Path(hdr_dir) + assert hdr_dir_path.is_dir() + assert (hdr_dir_path / SUPPORTED_HEADERS_NON_CTK[libname]).is_file() if have_distribution_for(libname): assert hdr_dir is not None - hdr_dir_parts = hdr_dir.split(os.path.sep) - assert "site-packages" in hdr_dir_parts + assert "site-packages" in Path(hdr_dir).parts elif STRICTNESS == "all_must_work": assert hdr_dir is not None if conda_prefix := os.environ.get("CONDA_PREFIX"): @@ -152,6 +152,8 @@ def test_locate_non_ctk_headers(info_summary_append, libname): inst_dirs = SUPPORTED_INSTALL_DIRS_NON_CTK.get(libname) if inst_dirs is not None: for inst_dir in inst_dirs: + # Absolute glob pattern: Path.glob needs a separate base dir, + # and the wildcard is not pinned to the last component. globbed = glob.glob(inst_dir) if hdr_dir in globbed: break @@ -172,9 +174,10 @@ def test_locate_ctk_headers(info_summary_append, libname): info_summary_append(f"{hdr_dir=!r}") if hdr_dir: _located_hdr_dir_asserts(located_hdr_dir) - assert os.path.isdir(hdr_dir) + hdr_dir_path = Path(hdr_dir) + assert hdr_dir_path.is_dir() h_filename = SUPPORTED_HEADERS_CTK[libname] - assert os.path.isfile(os.path.join(hdr_dir, h_filename)) + assert (hdr_dir_path / h_filename).is_file() if STRICTNESS == "all_must_work": if libname == "cudla": skip_if_missing_libnvcudla_so(libname, timeout=30) diff --git a/cuda_pathfinder/tests/test_find_static_lib.py b/cuda_pathfinder/tests/test_find_static_lib.py index 6d29a8def11..cf0e62dc8a2 100644 --- a/cuda_pathfinder/tests/test_find_static_lib.py +++ b/cuda_pathfinder/tests/test_find_static_lib.py @@ -52,7 +52,7 @@ def _located_static_lib_asserts(located_static_lib): assert isinstance(located_static_lib.filename, str) assert isinstance(located_static_lib.found_via, str) assert located_static_lib.found_via in ("site-packages", "conda", "CUDA_PATH") - assert os.path.isfile(located_static_lib.abs_path) + assert Path(located_static_lib.abs_path).is_file() @pytest.mark.usefixtures("clear_find_static_lib_cache") @@ -69,10 +69,10 @@ def test_locate_static_lib(info_summary_append, libname): info_summary_append(f"abs_path={quote_for_shell(lib_path)}") _located_static_lib_asserts(located_lib) - assert os.path.isfile(lib_path) + assert Path(lib_path).is_file() assert lib_path == located_lib.abs_path expected_filename = located_lib.filename - assert os.path.basename(lib_path) == expected_filename + assert Path(lib_path).name == expected_filename @pytest.mark.usefixtures("clear_find_static_lib_cache") @@ -81,7 +81,7 @@ def test_locate_static_lib_search_order(monkeypatch, tmp_path): conda_rel_path = CUDADEVRT_INFO["conda_rel_paths"][0] site_pkg_rel = CUDADEVRT_INFO["site_packages_dirs"][0] - site_packages_lib_dir = tmp_path / "site-packages" / Path(site_pkg_rel.replace("/", os.sep)) + site_packages_lib_dir = tmp_path / "site-packages" / Path(site_pkg_rel) site_packages_path = _make_static_lib_file(site_packages_lib_dir, filename) conda_prefix = tmp_path / "conda-prefix" @@ -202,7 +202,7 @@ def test_find_static_lib_not_found_error_includes_cuda_home_directory_listing(mo find_static_lib("cudadevrt") message = str(exc_info.value) - expected_missing_file = os.path.join(str(lib_dir), filename) + expected_missing_file = lib_dir / filename assert f"No such file: {expected_missing_file}" in message assert f'listdir("{lib_dir}"):' in message assert "README.txt" in message diff --git a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py index 810ddc71aa0..66ede86c6ad 100644 --- a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py +++ b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py @@ -3,6 +3,7 @@ import os import platform +from pathlib import Path import pytest from child_load_nvidia_dynamic_lib_helper import ( @@ -159,4 +160,4 @@ def raise_child_process_failed(): abs_path = payload.abs_path assert abs_path is not None info_summary_append(f"abs_path={quote_for_shell(abs_path)}") - assert os.path.isfile(abs_path) # double-check the abs_path + assert Path(abs_path).is_file() # double-check the abs_path diff --git a/cuda_pathfinder/tests/test_utils_find_sub_dirs.py b/cuda_pathfinder/tests/test_utils_find_sub_dirs.py index a647e66099b..56dab23dc42 100644 --- a/cuda_pathfinder/tests/test_utils_find_sub_dirs.py +++ b/cuda_pathfinder/tests/test_utils_find_sub_dirs.py @@ -1,7 +1,7 @@ # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 -import os +from pathlib import Path import pytest @@ -77,7 +77,7 @@ def test_empty_parent_paths(): def test_empty_sub_dirs(test_tree): parent_paths = test_tree["parent_paths"] result = find_sub_dirs(parent_paths, ()) - expected = [p for p in parent_paths if os.path.isdir(p)] + expected = [p for p in parent_paths if Path(p).is_dir()] assert sorted(result) == sorted(expected) From 16f9c580cafa7631c812387e061a2f0ae3caa9ee Mon Sep 17 00:00:00 2001 From: Rui Luo Date: Fri, 7 Aug 2026 09:25:17 -0700 Subject: [PATCH 39/50] coverage: repair the Windows coverage wheels (#2508) Windows coverage has not collected a test since 2026-03-17. The job builds its wheels with a plain `pip wheel`, which never reads [tool.cibuildwheel], so the delvewheel repair every other Windows build performs never ran here. Those wheels import a bare "MSVCP140.dll" and resolve it against whatever the test machine has in System32, which on the coverage runner is 14.00.24215.1, built in 2015. _resource_handles.pyd is compiled by MSVC 14.44 and imports exactly _Mtx_lock and _Mtx_unlock from that DLL -- never _Mtx_init_in_situ, because std::mutex has had a constexpr constructor since VS 2022 17.10. The 2015 runtime still expects that initialisation and dereferences a null handle on the first lock, which _stream.pyx takes while cuda.core is still importing. It is the only extension module in either package that locks a mutex, which is why cuda.bindings and cuda.pathfinder have always passed on the same machine. Repairing the wheels vendors msvcp140 14.44 into cuda_core.libs and rewrites the import tables to match, so the process no longer depends on what the test machine carries. Verified on the coverage runner: 18 failed, 2929 passed, 918 skipped in 346s, against three to seven seconds of dying beforehand, and the first Windows coverage data since March. The same commit pins cuda-bindings to the wheel built one step earlier. PIP_PRE is set so pip will consider that wheel at all -- it carries a .devN version -- but it also admits PyPI's pre-releases, and cuda-bindings 13.4.0b1, published 2026-07-29, outranks the local build. Its cydriver.pxd comes from CTK 13.4 headers where CUmemLocation has a `localized` field, while cuda.core compiles against the 13.3.0 mini-CTK where it does not, so the build has been failing on `error C2039` ever since. Signed-off-by: Rui Luo --- .github/workflows/coverage.yml | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index e354a204d02..ecc90674c78 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -235,13 +235,34 @@ jobs: cd cuda_bindings ../.venv/Scripts/pip wheel -v --no-deps . -w ../wheels/ + # Pin cuda-bindings to the wheel built above; PIP_PRE, which is what makes + # that .devN wheel visible, would otherwise let a PyPI pre-release win. - name: Build cuda.core wheel run: | export PIP_FIND_LINKS="$(pwd)/wheels" export PIP_PRE=1 + bindings_whl="$(ls ./wheels/cuda_bindings-*.whl | head -1)" + bindings_ver="$(basename "$bindings_whl" | cut -d- -f2)" + echo "cuda-bindings==${bindings_ver%%+*}" > "$GITHUB_WORKSPACE/constraints.txt" + cat "$GITHUB_WORKSPACE/constraints.txt" + export PIP_CONSTRAINT="$GITHUB_WORKSPACE/constraints.txt" cd cuda_core ../.venv/Scripts/pip wheel -v --no-deps . -w ../wheels/ + # Vendor the DLLs these wheels were built against, the way cibuildwheel + # does for every other Windows build. --namespace-pkg is needed because + # `cuda` is a namespace package. + - name: Repair the Windows wheels + run: | + .venv/Scripts/pip install delvewheel + mkdir -p wheels-repaired + for whl in ./wheels/cuda_bindings-*.whl ./wheels/cuda_core-*.whl; do + .venv/Scripts/delvewheel repair --namespace-pkg cuda \ + --exclude "torch_cpu.dll;torch_python.dll" \ + -w ./wheels-repaired "$whl" + done + mv -f ./wheels-repaired/*.whl ./wheels/ + - name: List wheel artifacts run: | echo "=== Windows wheel artifacts ===" From 459e0e9ce88e82c0ad6ae7feb45b839c774f595f Mon Sep 17 00:00:00 2001 From: Aryan Putta Date: Fri, 7 Aug 2026 13:24:24 -0400 Subject: [PATCH 40/50] cuda.core: accept ProgramOptions(name=None) (#2517) * cuda.core: accept ProgramOptions(name=None) ProgramOptions.name is annotated str | None, but __post_init__ called .encode() on it unconditionally, so passing None raised AttributeError before any CUDA call was reached. Normalize None to the documented default, matching how arch is handled in the same method. The encoded value is identical to the existing default path, so the bytes passed to nvrtcCreateProgram are unchanged. Signed-off-by: Aryan * cuda.core: cover name=None through compile and add a release note Extend coverage past ProgramOptions construction to assert the normalized name reaches ObjectCode.name, matching the shape of test_program_compile_valid_target_type. Signed-off-by: Aryan * cuda.core: drop the redundant compile-level test and the name constant ObjectCode.name receives an already-normalized options.name, so the compile-level assertion could not fail independently of the options test. Inline the default literal instead of a module constant, which kept a private symbol out of the generated stub. Signed-off-by: Aryan --------- Signed-off-by: Aryan Co-authored-by: Michael Droettboom --- cuda_core/cuda/core/_program.pyi | 1 + cuda_core/cuda/core/_program.pyx | 4 ++++ cuda_core/docs/source/release/1.2.0-notes.rst | 6 ++++++ cuda_core/tests/test_program.py | 10 ++++++++++ 4 files changed, 21 insertions(+) diff --git a/cuda_core/cuda/core/_program.pyi b/cuda_core/cuda/core/_program.pyi index df7ed66446a..d046523b007 100644 --- a/cuda_core/cuda/core/_program.pyi +++ b/cuda_core/cuda/core/_program.pyi @@ -145,6 +145,7 @@ class ProgramOptions: ---------- name : str, optional Name of the program. If the compilation succeeds, the name is passed down to the generated :class:`ObjectCode`. + When set to `None`, ``"default_program"`` is used. arch : str, optional Pass the SM architecture value, such as ``sm_`` (for generating CUBIN) or ``compute_`` (for generating PTX). If not provided, the current device's architecture diff --git a/cuda_core/cuda/core/_program.pyx b/cuda_core/cuda/core/_program.pyx index 27b1e5aa914..7fb099b06d2 100644 --- a/cuda_core/cuda/core/_program.pyx +++ b/cuda_core/cuda/core/_program.pyx @@ -298,6 +298,7 @@ class ProgramOptions: ---------- name : str, optional Name of the program. If the compilation succeeds, the name is passed down to the generated :class:`ObjectCode`. + When set to `None`, ``"default_program"`` is used. arch : str, optional Pass the SM architecture value, such as ``sm_`` (for generating CUBIN) or ``compute_`` (for generating PTX). If not provided, the current device's architecture @@ -523,6 +524,9 @@ class ProgramOptions: numba_debug: bool | None = None # Custom option for Numba debugging def __post_init__(self) -> None: + # Set name to default if not provided + if self.name is None: + self.name = "default_program" self._name = self.name.encode() # Set arch to default if not provided if self.arch is None: diff --git a/cuda_core/docs/source/release/1.2.0-notes.rst b/cuda_core/docs/source/release/1.2.0-notes.rst index 4bb81cec759..ffd82331f39 100644 --- a/cuda_core/docs/source/release/1.2.0-notes.rst +++ b/cuda_core/docs/source/release/1.2.0-notes.rst @@ -53,6 +53,12 @@ Fixes and enhancements (`#2409 `__, closes `#2408 `__) +- :class:`ProgramOptions` now accepts ``name=None`` and falls back to the + documented default ``"default_program"``. Previously the annotated and + documented ``None`` raised ``AttributeError`` during construction. + (`#2517 `__, + closes `#2516 `__) + Deprecation Notices ------------------- diff --git a/cuda_core/tests/test_program.py b/cuda_core/tests/test_program.py index a9dc4966346..28465425c0e 100644 --- a/cuda_core/tests/test_program.py +++ b/cuda_core/tests/test_program.py @@ -351,6 +351,16 @@ def test_program_init_invalid_code_format(): Program(code, "c++") +# arch is passed explicitly so the current device is not queried. +@pytest.mark.agent_authored(model="claude-opus-5") +@pytest.mark.parametrize("name", [None, "my_program"]) +def test_program_options_name_accepts_none(name): + options = ProgramOptions(name=name, arch="sm_90") + expected = "default_program" if name is None else name + assert options.name == expected + assert options._name == expected.encode() + + # This is tested against the current device's arch def test_program_compile_valid_target_type(init_cuda): code = 'extern "C" __global__ void my_kernel() {}' From 9ec417f3e49b2e5a6c073299ce2488dde9918859 Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Fri, 7 Aug 2026 13:13:08 -0700 Subject: [PATCH 41/50] cuda.bindings: Fix API status handling (#2530) * cuda.bindings tests: enable BAR lookup test on GH200 * cuda_bindings fixes --------- Co-authored-by: Ralf Juengling --- .github/workflows/test-wheel-linux.yml | 3 - .../cuda/bindings/_internal/cufile.pxd | 16 ++- .../cuda/bindings/_internal/cufile_linux.pyx | 103 +++++++++--------- cuda_bindings/cuda/bindings/cufile.pxd | 10 +- cuda_bindings/cuda/bindings/cufile.pyx | 18 ++- cuda_bindings/cuda/bindings/cycufile.pxd | 29 ++++- cuda_bindings/cuda/bindings/cycufile.pyx | 9 +- 7 files changed, 114 insertions(+), 74 deletions(-) diff --git a/.github/workflows/test-wheel-linux.yml b/.github/workflows/test-wheel-linux.yml index a4d5d9511d3..f2e7e5e5d39 100644 --- a/.github/workflows/test-wheel-linux.yml +++ b/.github/workflows/test-wheel-linux.yml @@ -346,9 +346,6 @@ jobs: env: CUDA_VER: ${{ matrix.CUDA_VER }} LOCAL_CTK: ${{ matrix.LOCAL_CTK }} - # #2299: BAR-size query returns CUDA_ERROR_NOT_SUPPORTED on G+H; - # skip the test on gh200 runners until upstream cufile guards it. - PYTEST_ADDOPTS: ${{ matrix.GPU == 'gh200' && '--deselect tests/test_cufile.py::test_get_bar_size_in_kb' || '' }} run: run-tests bindings - name: Run cuda.bindings benchmarks (smoke test) diff --git a/cuda_bindings/cuda/bindings/_internal/cufile.pxd b/cuda_bindings/cuda/bindings/_internal/cufile.pxd index b8fe03b779d..41786b1f25b 100644 --- a/cuda_bindings/cuda/bindings/_internal/cufile.pxd +++ b/cuda_bindings/cuda/bindings/_internal/cufile.pxd @@ -3,8 +3,16 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1788ebb3c332e99a6dc0dcd98c5af472bf42c1c960ba70cb65f294a81712491d + + +# <<<< PREAMBLE CONTENT >>>> + +from libcpp cimport bool as _cyb_bool + + +# <<<< END OF PREAMBLE CONTENT >>>> -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b70fdd33eb00b70224c097fb28dd1031d82e8a2930356a4428c93e3bd1b52a86 from ..cycufile cimport * @@ -23,7 +31,7 @@ cdef CUfileError_t _cuFileDriverClose() except?CUFILE_LOADING_ERR cdef CUfileError_t _cuFileDriverClose_v2() except?CUFILE_LOADING_ERROR nogil cdef long _cuFileUseCount() except* nogil cdef CUfileError_t _cuFileDriverGetProperties(CUfileDrvProps_t* props) except?CUFILE_LOADING_ERROR nogil -cdef CUfileError_t _cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?CUFILE_LOADING_ERROR nogil +cdef CUfileError_t _cuFileDriverSetPollMode(_cyb_bool poll, size_t poll_threshold_size) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileDriverSetMaxDirectIOSize(size_t max_direct_io_size) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileDriverSetMaxCacheSize(size_t max_cache_size) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileDriverSetMaxPinnedMemSize(size_t max_pinned_size) except?CUFILE_LOADING_ERROR nogil @@ -38,10 +46,10 @@ cdef CUfileError_t _cuFileStreamRegister(CUstream stream, unsigned flags) except cdef CUfileError_t _cuFileStreamDeregister(CUstream stream) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileGetVersion(int* version) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t* value) except?CUFILE_LOADING_ERROR nogil -cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?CUFILE_LOADING_ERROR nogil +cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool* value) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileGetParameterString(CUFileStringConfigParameter_t param, char* desc_str, int len) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t value) except?CUFILE_LOADING_ERROR nogil -cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?CUFILE_LOADING_ERROR nogil +cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool value) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileSetParameterString(CUFileStringConfigParameter_t param, const char* desc_str) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileGetParameterMinMaxValue(CUFileSizeTConfigParameter_t param, size_t* min_value, size_t* max_value) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t _cuFileSetStatsLevel(int level) except?CUFILE_LOADING_ERROR nogil diff --git a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx index 1491c4588aa..4bd16e9ec4a 100644 --- a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=73d6889e33bb56f1e0e63be7a0ba1f176c5c09e6e1adf9c4360d23335e131260 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5b6e0791dac3bac268169b02ebc748d7375de7189fe7114151716d47791519ad # <<<< PREAMBLE CONTENT >>>> @@ -45,7 +45,8 @@ cdef extern from "": const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" cimport cython as _cyb_cython -from libc.stdint cimport intptr_t as _cyb_intptr_t +from libc.stdint cimport intptr_t +from libcpp cimport bool as _cyb_bool import threading as _cyb_threading @@ -435,133 +436,133 @@ cpdef dict _inspect_function_pointers(): _check_or_init_cufile() cdef dict data = {} global __cuFileHandleRegister - data["__cuFileHandleRegister"] = <_cyb_intptr_t>__cuFileHandleRegister + data["__cuFileHandleRegister"] = __cuFileHandleRegister global __cuFileHandleDeregister - data["__cuFileHandleDeregister"] = <_cyb_intptr_t>__cuFileHandleDeregister + data["__cuFileHandleDeregister"] = __cuFileHandleDeregister global __cuFileBufRegister - data["__cuFileBufRegister"] = <_cyb_intptr_t>__cuFileBufRegister + data["__cuFileBufRegister"] = __cuFileBufRegister global __cuFileBufDeregister - data["__cuFileBufDeregister"] = <_cyb_intptr_t>__cuFileBufDeregister + data["__cuFileBufDeregister"] = __cuFileBufDeregister global __cuFileRead - data["__cuFileRead"] = <_cyb_intptr_t>__cuFileRead + data["__cuFileRead"] = __cuFileRead global __cuFileWrite - data["__cuFileWrite"] = <_cyb_intptr_t>__cuFileWrite + data["__cuFileWrite"] = __cuFileWrite global __cuFileDriverOpen - data["__cuFileDriverOpen"] = <_cyb_intptr_t>__cuFileDriverOpen + data["__cuFileDriverOpen"] = __cuFileDriverOpen global __cuFileDriverClose - data["__cuFileDriverClose"] = <_cyb_intptr_t>__cuFileDriverClose + data["__cuFileDriverClose"] = __cuFileDriverClose global __cuFileDriverClose_v2 - data["__cuFileDriverClose_v2"] = <_cyb_intptr_t>__cuFileDriverClose_v2 + data["__cuFileDriverClose_v2"] = __cuFileDriverClose_v2 global __cuFileUseCount - data["__cuFileUseCount"] = <_cyb_intptr_t>__cuFileUseCount + data["__cuFileUseCount"] = __cuFileUseCount global __cuFileDriverGetProperties - data["__cuFileDriverGetProperties"] = <_cyb_intptr_t>__cuFileDriverGetProperties + data["__cuFileDriverGetProperties"] = __cuFileDriverGetProperties global __cuFileDriverSetPollMode - data["__cuFileDriverSetPollMode"] = <_cyb_intptr_t>__cuFileDriverSetPollMode + data["__cuFileDriverSetPollMode"] = __cuFileDriverSetPollMode global __cuFileDriverSetMaxDirectIOSize - data["__cuFileDriverSetMaxDirectIOSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxDirectIOSize + data["__cuFileDriverSetMaxDirectIOSize"] = __cuFileDriverSetMaxDirectIOSize global __cuFileDriverSetMaxCacheSize - data["__cuFileDriverSetMaxCacheSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxCacheSize + data["__cuFileDriverSetMaxCacheSize"] = __cuFileDriverSetMaxCacheSize global __cuFileDriverSetMaxPinnedMemSize - data["__cuFileDriverSetMaxPinnedMemSize"] = <_cyb_intptr_t>__cuFileDriverSetMaxPinnedMemSize + data["__cuFileDriverSetMaxPinnedMemSize"] = __cuFileDriverSetMaxPinnedMemSize global __cuFileBatchIOSetUp - data["__cuFileBatchIOSetUp"] = <_cyb_intptr_t>__cuFileBatchIOSetUp + data["__cuFileBatchIOSetUp"] = __cuFileBatchIOSetUp global __cuFileBatchIOSubmit - data["__cuFileBatchIOSubmit"] = <_cyb_intptr_t>__cuFileBatchIOSubmit + data["__cuFileBatchIOSubmit"] = __cuFileBatchIOSubmit global __cuFileBatchIOGetStatus - data["__cuFileBatchIOGetStatus"] = <_cyb_intptr_t>__cuFileBatchIOGetStatus + data["__cuFileBatchIOGetStatus"] = __cuFileBatchIOGetStatus global __cuFileBatchIOCancel - data["__cuFileBatchIOCancel"] = <_cyb_intptr_t>__cuFileBatchIOCancel + data["__cuFileBatchIOCancel"] = __cuFileBatchIOCancel global __cuFileBatchIODestroy - data["__cuFileBatchIODestroy"] = <_cyb_intptr_t>__cuFileBatchIODestroy + data["__cuFileBatchIODestroy"] = __cuFileBatchIODestroy global __cuFileReadAsync - data["__cuFileReadAsync"] = <_cyb_intptr_t>__cuFileReadAsync + data["__cuFileReadAsync"] = __cuFileReadAsync global __cuFileWriteAsync - data["__cuFileWriteAsync"] = <_cyb_intptr_t>__cuFileWriteAsync + data["__cuFileWriteAsync"] = __cuFileWriteAsync global __cuFileStreamRegister - data["__cuFileStreamRegister"] = <_cyb_intptr_t>__cuFileStreamRegister + data["__cuFileStreamRegister"] = __cuFileStreamRegister global __cuFileStreamDeregister - data["__cuFileStreamDeregister"] = <_cyb_intptr_t>__cuFileStreamDeregister + data["__cuFileStreamDeregister"] = __cuFileStreamDeregister global __cuFileGetVersion - data["__cuFileGetVersion"] = <_cyb_intptr_t>__cuFileGetVersion + data["__cuFileGetVersion"] = __cuFileGetVersion global __cuFileGetParameterSizeT - data["__cuFileGetParameterSizeT"] = <_cyb_intptr_t>__cuFileGetParameterSizeT + data["__cuFileGetParameterSizeT"] = __cuFileGetParameterSizeT global __cuFileGetParameterBool - data["__cuFileGetParameterBool"] = <_cyb_intptr_t>__cuFileGetParameterBool + data["__cuFileGetParameterBool"] = __cuFileGetParameterBool global __cuFileGetParameterString - data["__cuFileGetParameterString"] = <_cyb_intptr_t>__cuFileGetParameterString + data["__cuFileGetParameterString"] = __cuFileGetParameterString global __cuFileSetParameterSizeT - data["__cuFileSetParameterSizeT"] = <_cyb_intptr_t>__cuFileSetParameterSizeT + data["__cuFileSetParameterSizeT"] = __cuFileSetParameterSizeT global __cuFileSetParameterBool - data["__cuFileSetParameterBool"] = <_cyb_intptr_t>__cuFileSetParameterBool + data["__cuFileSetParameterBool"] = __cuFileSetParameterBool global __cuFileSetParameterString - data["__cuFileSetParameterString"] = <_cyb_intptr_t>__cuFileSetParameterString + data["__cuFileSetParameterString"] = __cuFileSetParameterString global __cuFileGetParameterMinMaxValue - data["__cuFileGetParameterMinMaxValue"] = <_cyb_intptr_t>__cuFileGetParameterMinMaxValue + data["__cuFileGetParameterMinMaxValue"] = __cuFileGetParameterMinMaxValue global __cuFileSetStatsLevel - data["__cuFileSetStatsLevel"] = <_cyb_intptr_t>__cuFileSetStatsLevel + data["__cuFileSetStatsLevel"] = __cuFileSetStatsLevel global __cuFileGetStatsLevel - data["__cuFileGetStatsLevel"] = <_cyb_intptr_t>__cuFileGetStatsLevel + data["__cuFileGetStatsLevel"] = __cuFileGetStatsLevel global __cuFileStatsStart - data["__cuFileStatsStart"] = <_cyb_intptr_t>__cuFileStatsStart + data["__cuFileStatsStart"] = __cuFileStatsStart global __cuFileStatsStop - data["__cuFileStatsStop"] = <_cyb_intptr_t>__cuFileStatsStop + data["__cuFileStatsStop"] = __cuFileStatsStop global __cuFileStatsReset - data["__cuFileStatsReset"] = <_cyb_intptr_t>__cuFileStatsReset + data["__cuFileStatsReset"] = __cuFileStatsReset global __cuFileGetStatsL1 - data["__cuFileGetStatsL1"] = <_cyb_intptr_t>__cuFileGetStatsL1 + data["__cuFileGetStatsL1"] = __cuFileGetStatsL1 global __cuFileGetStatsL2 - data["__cuFileGetStatsL2"] = <_cyb_intptr_t>__cuFileGetStatsL2 + data["__cuFileGetStatsL2"] = __cuFileGetStatsL2 global __cuFileGetStatsL3 - data["__cuFileGetStatsL3"] = <_cyb_intptr_t>__cuFileGetStatsL3 + data["__cuFileGetStatsL3"] = __cuFileGetStatsL3 global __cuFileGetBARSizeInKB - data["__cuFileGetBARSizeInKB"] = <_cyb_intptr_t>__cuFileGetBARSizeInKB + data["__cuFileGetBARSizeInKB"] = __cuFileGetBARSizeInKB global __cuFileSetParameterPosixPoolSlabArray - data["__cuFileSetParameterPosixPoolSlabArray"] = <_cyb_intptr_t>__cuFileSetParameterPosixPoolSlabArray + data["__cuFileSetParameterPosixPoolSlabArray"] = __cuFileSetParameterPosixPoolSlabArray global __cuFileGetParameterPosixPoolSlabArray - data["__cuFileGetParameterPosixPoolSlabArray"] = <_cyb_intptr_t>__cuFileGetParameterPosixPoolSlabArray + data["__cuFileGetParameterPosixPoolSlabArray"] = __cuFileGetParameterPosixPoolSlabArray _cyb_func_ptrs = data return data @@ -694,13 +695,13 @@ cdef CUfileError_t _cuFileDriverGetProperties(CUfileDrvProps_t* props) except?CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t _cuFileDriverSetPollMode(_cyb_bool poll, size_t poll_threshold_size) except?CUFILE_LOADING_ERROR nogil: global __cuFileDriverSetPollMode _check_or_init_cufile() if __cuFileDriverSetPollMode == NULL: with gil: raise FunctionNotFoundError("function cuFileDriverSetPollMode is not found") - return (__cuFileDriverSetPollMode)( + return (__cuFileDriverSetPollMode)( poll, poll_threshold_size) @@ -845,13 +846,13 @@ cdef CUfileError_t _cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, param, value) -cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t _cuFileGetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool* value) except?CUFILE_LOADING_ERROR nogil: global __cuFileGetParameterBool _check_or_init_cufile() if __cuFileGetParameterBool == NULL: with gil: raise FunctionNotFoundError("function cuFileGetParameterBool is not found") - return (__cuFileGetParameterBool)( + return (__cuFileGetParameterBool)( param, value) @@ -875,13 +876,13 @@ cdef CUfileError_t _cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, param, value) -cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t _cuFileSetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool value) except?CUFILE_LOADING_ERROR nogil: global __cuFileSetParameterBool _check_or_init_cufile() if __cuFileSetParameterBool == NULL: with gil: raise FunctionNotFoundError("function cuFileSetParameterBool is not found") - return (__cuFileSetParameterBool)( + return (__cuFileSetParameterBool)( param, value) diff --git a/cuda_bindings/cuda/bindings/cufile.pxd b/cuda_bindings/cuda/bindings/cufile.pxd index 2bd8c7489ca..74633880658 100644 --- a/cuda_bindings/cuda/bindings/cufile.pxd +++ b/cuda_bindings/cuda/bindings/cufile.pxd @@ -3,9 +3,17 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b10e4f1751ee5423db23c6fc953cb0ae37bff7e8937bf1d39ac5fd6eeb0e4e87 + + + +# <<<< PREAMBLE CONTENT >>>> -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=232df43b5a8960f10286c172abc71222a3822087a1f6134e12d9341f3b53886c from libc.stdint cimport intptr_t +from libcpp cimport bool as _cyb_bool + + +# <<<< END OF PREAMBLE CONTENT >>>> from .cycufile cimport * diff --git a/cuda_bindings/cuda/bindings/cufile.pyx b/cuda_bindings/cuda/bindings/cufile.pyx index b81346dcad9..8130a9b6297 100644 --- a/cuda_bindings/cuda/bindings/cufile.pyx +++ b/cuda_bindings/cuda/bindings/cufile.pyx @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f107413ea0012a1a854cd3de77d57f649bebd0f586901d4e6384f37288ac5421 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1ca8c2d672c5799154a85a73ac7f0f3661943ece8f4d7c1d2e11649a0a537c81 # <<<< PREAMBLE CONTENT >>>> @@ -12,6 +12,10 @@ cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer cimport cpython.memoryview as _cyb_cpython_memoryview from cython cimport view as _cyb_view +from libc.stdint cimport ( + intptr_t, + uint64_t, +) from libc.stdlib cimport ( calloc as _cyb_calloc, free as _cyb_free, @@ -21,6 +25,7 @@ from libc.string cimport ( memcmp as _cyb_memcmp, memcpy as _cyb_memcpy, ) +from libcpp cimport bool as _cyb_bool from cuda.bindings._internal._fast_enum import FastEnum as _cyb_FastEnum @@ -2986,9 +2991,12 @@ class cuFileError(Exception): @cython.profile(False) cdef int check_status(ReturnT status) except 1 nogil: if ReturnT is CUfileError_t: - if status.err != 0 or status.cu_err != 0: + if IS_CUDA_ERR(status): with gil: raise cuFileError(status.err, status.cu_err) + elif IS_CUFILE_ERR(status.err): + with gil: + raise cuFileError(status.err) elif ReturnT is ssize_t: if status == -1: # note: this assumes cuFile already properly resets errno in each API @@ -3107,7 +3115,7 @@ cpdef driver_set_poll_mode(bint poll, size_t poll_threshold_size): .. seealso:: `cuFileDriverSetPollMode` """ with nogil: - __status__ = cuFileDriverSetPollMode(poll, poll_threshold_size) + __status__ = cuFileDriverSetPollMode(<_cyb_bool>poll, poll_threshold_size) check_status(__status__) @@ -3232,7 +3240,7 @@ cpdef size_t get_parameter_size_t(int param) except? 0: cpdef bint get_parameter_bool(int param) except? 0: - cdef cpp_bool value + cdef _cyb_bool value with nogil: __status__ = cuFileGetParameterBool(<_BoolConfigParameter>param, &value) check_status(__status__) @@ -3256,7 +3264,7 @@ cpdef set_parameter_size_t(int param, size_t value): cpdef set_parameter_bool(int param, bint value): with nogil: - __status__ = cuFileSetParameterBool(<_BoolConfigParameter>param, value) + __status__ = cuFileSetParameterBool(<_BoolConfigParameter>param, <_cyb_bool>value) check_status(__status__) diff --git a/cuda_bindings/cuda/bindings/cycufile.pxd b/cuda_bindings/cuda/bindings/cycufile.pxd index b5a0c9cb884..ac614bf80da 100644 --- a/cuda_bindings/cuda/bindings/cycufile.pxd +++ b/cuda_bindings/cuda/bindings/cycufile.pxd @@ -3,11 +3,21 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=1051fa856de24c84b3c8d3b2996adb28c5db2530a86f49c240b05eb0dab0954d + + +# <<<< PREAMBLE CONTENT >>>> + +from libc.stdint cimport ( + uint32_t, + uint64_t, +) +from libcpp cimport bool as _cyb_bool + + +# <<<< END OF PREAMBLE CONTENT >>>> -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f840820f160e36eebe6e052b5a5d3a35b55704060301ee2ab7d5cd7a7d580418 -from libc.stdint cimport uint32_t, uint64_t from libc.time cimport time_t -from libcpp cimport bool as cpp_bool from posix.types cimport off_t cimport cuda.bindings.cydriver @@ -371,6 +381,13 @@ cdef extern from 'cufile.h': CUfilePerGpuStats_t per_gpu_stats[16] +# Error-inspection macros from cufile.h (declared as functions so Cython +# emits calls that the C preprocessor expands). +cdef extern from 'cufile.h' nogil: + bint IS_CUDA_ERR(CUfileError_t status) + bint IS_CUFILE_ERR(CUfileOpError err) + + cdef extern from *: """ // This is the missing piece we need to supply to help Cython & C++ compilers. @@ -400,7 +417,7 @@ cdef CUfileError_t cuFileDriverClose() except?CUFILE_LOADING_ERRO cdef CUfileError_t cuFileDriverClose_v2() except?CUFILE_LOADING_ERROR nogil cdef long cuFileUseCount() except* nogil cdef CUfileError_t cuFileDriverGetProperties(CUfileDrvProps_t* props) except?CUFILE_LOADING_ERROR nogil -cdef CUfileError_t cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?CUFILE_LOADING_ERROR nogil +cdef CUfileError_t cuFileDriverSetPollMode(_cyb_bool poll, size_t poll_threshold_size) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileDriverSetMaxDirectIOSize(size_t max_direct_io_size) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileDriverSetMaxCacheSize(size_t max_cache_size) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileDriverSetMaxPinnedMemSize(size_t max_pinned_size) except?CUFILE_LOADING_ERROR nogil @@ -415,10 +432,10 @@ cdef CUfileError_t cuFileStreamRegister(CUstream stream, unsigned flags) except? cdef CUfileError_t cuFileStreamDeregister(CUstream stream) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileGetVersion(int* version) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t* value) except?CUFILE_LOADING_ERROR nogil -cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?CUFILE_LOADING_ERROR nogil +cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool* value) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileGetParameterString(CUFileStringConfigParameter_t param, char* desc_str, int len) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t value) except?CUFILE_LOADING_ERROR nogil -cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?CUFILE_LOADING_ERROR nogil +cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool value) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileSetParameterString(CUFileStringConfigParameter_t param, const char* desc_str) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileGetParameterMinMaxValue(CUFileSizeTConfigParameter_t param, size_t* min_value, size_t* max_value) except?CUFILE_LOADING_ERROR nogil cdef CUfileError_t cuFileSetStatsLevel(int level) except?CUFILE_LOADING_ERROR nogil diff --git a/cuda_bindings/cuda/bindings/cycufile.pyx b/cuda_bindings/cuda/bindings/cycufile.pyx index c8d240560b0..ef94b75c02e 100644 --- a/cuda_bindings/cuda/bindings/cycufile.pyx +++ b/cuda_bindings/cuda/bindings/cycufile.pyx @@ -3,12 +3,13 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a68ff13250f4b5131f4b4adf8a37a4283b27749e8429b5f6e57bfc68bf656b00 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=21f23d353f9a8d02c92a5c5740cfa8bed67c952fbf262b8181fdfb6f65e52a73 # <<<< PREAMBLE CONTENT >>>> cimport cython as _cyb_cython +from libcpp cimport bool as _cyb_bool # <<<< END OF PREAMBLE CONTENT >>>> @@ -66,7 +67,7 @@ cdef CUfileError_t cuFileDriverGetProperties(CUfileDrvProps_t* props) except?CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t cuFileDriverSetPollMode(_cyb_bool poll, size_t poll_threshold_size) except?CUFILE_LOADING_ERROR nogil: return _cufile._cuFileDriverSetPollMode(poll, poll_threshold_size) @@ -127,7 +128,7 @@ cdef CUfileError_t cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, s return _cufile._cuFileGetParameterSizeT(param, value) -cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool* value) except?CUFILE_LOADING_ERROR nogil: return _cufile._cuFileGetParameterBool(param, value) @@ -139,7 +140,7 @@ cdef CUfileError_t cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, s return _cufile._cuFileSetParameterSizeT(param, value) -cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?CUFILE_LOADING_ERROR nogil: +cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, _cyb_bool value) except?CUFILE_LOADING_ERROR nogil: return _cufile._cuFileSetParameterBool(param, value) From 5199241d84019281207db1166e7f734c58de6cdc Mon Sep 17 00:00:00 2001 From: Uday Arora <86965450+uday1o1@users.noreply.github.com> Date: Fri, 7 Aug 2026 13:32:22 -0700 Subject: [PATCH 42/50] cuda.core: validate pinned host memory pool support (#2487) * cuda.core: validate pinned pool support Reject unsupported host memory pools during allocation instead of allowing a later copy to fail with CUDA_ERROR_INVALID_VALUE. Signed-off-by: Uday Arora * cuda.core: tighten pinned host pool capability check Drop the unnecessary CUDA 12 fence around host_memory_pools_supported, raise RuntimeError instead of a synthetic CUDAError, and keep the regression test hardware-gated for devices without host memory pools. --------- Signed-off-by: Uday Arora Co-authored-by: Andy Jost --- cuda_core/cuda/core/_device.pyx | 40 ++++++++++++------- .../core/_memory/_pinned_memory_resource.pyi | 14 +++++++ .../core/_memory/_pinned_memory_resource.pyx | 37 ++++++++++++++++- cuda_core/tests/test_device.py | 18 ++------- cuda_core/tests/test_memory.py | 20 ++++++++++ 5 files changed, 100 insertions(+), 29 deletions(-) diff --git a/cuda_core/cuda/core/_device.pyx b/cuda_core/cuda/core/_device.pyx index 29740cb466a..a0a0f472f2b 100644 --- a/cuda_core/cuda/core/_device.pyx +++ b/cuda_core/cuda/core/_device.pyx @@ -924,34 +924,46 @@ cdef class DeviceProperties: @property def host_memory_pools_supported(self) -> bool: """bool: Device supports HOST location with the cuMemAllocAsync and cuMemPool family of APIs.""" - return bool( - self._get_cached_attribute(driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_MEMORY_POOLS_SUPPORTED) - ) + IF CUDA_CORE_BUILD_MAJOR < 13: + return False + ELSE: + return bool( + self._get_cached_attribute(driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_MEMORY_POOLS_SUPPORTED) + ) @property def host_virtual_memory_management_supported(self) -> bool: """bool: Device supports HOST location with the virtual memory management APIs like cuMemCreate, cuMemMap and related APIs.""" - return bool( - self._get_cached_attribute( - driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED + IF CUDA_CORE_BUILD_MAJOR < 13: + return False + ELSE: + return bool( + self._get_cached_attribute( + driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED + ) ) - ) @property def host_alloc_dma_buf_supported(self) -> bool: """bool: Device supports page-locked host memory buffer sharing with dma_buf mechanism.""" - return bool( - self._get_cached_attribute(driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_ALLOC_DMA_BUF_SUPPORTED) - ) + IF CUDA_CORE_BUILD_MAJOR < 13: + return False + ELSE: + return bool( + self._get_cached_attribute(driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_ALLOC_DMA_BUF_SUPPORTED) + ) @property def only_partial_host_native_atomic_supported(self) -> bool: """bool: Link between the device and the host supports only some native atomic operations.""" - return bool( - self._get_cached_attribute( - driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_ONLY_PARTIAL_HOST_NATIVE_ATOMIC_SUPPORTED + IF CUDA_CORE_BUILD_MAJOR < 13: + return False + ELSE: + return bool( + self._get_cached_attribute( + driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_ONLY_PARTIAL_HOST_NATIVE_ATOMIC_SUPPORTED + ) ) - ) class Device: diff --git a/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyi b/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyi index a83cd8ea581..9cad97a1d0d 100644 --- a/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyi +++ b/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyi @@ -5,8 +5,11 @@ from __future__ import annotations import uuid from dataclasses import dataclass +from cuda.core._memory._buffer import Buffer from cuda.core._memory._ipc import IPCAllocationHandle from cuda.core._memory._memory_pool import _MemPool +from cuda.core._stream import Stream +from cuda.core.graph import GraphBuilder @dataclass @@ -63,6 +66,14 @@ class PinnedMemoryResource(_MemPool): Notes ----- + The device associated with ``stream`` must support host memory pools. If + ``numa_id`` is set or derived for IPC, it must support host NUMA memory pools. + You can query these capabilities through + ``Device.properties.host_memory_pools_supported`` and + ``Device.properties.host_numa_memory_pools_supported``. If the required pool + is unsupported and stream-ordered allocation is not needed, use + :class:`LegacyPinnedMemoryResource`. + To create an IPC-Enabled memory resource (MR) that is capable of sharing allocations between processes, specify ``ipc_enabled=True`` in the initializer option. When IPC is enabled and ``numa_id`` is not specified, the NUMA node @@ -76,6 +87,9 @@ class PinnedMemoryResource(_MemPool): def __init__(self, options: PinnedMemoryResourceOptions | dict[str, object] | None=None) -> None: ... + def allocate(self, size: int, *, stream: Stream | GraphBuilder) -> Buffer: + """Allocate a host-pinned buffer asynchronously on the supplied stream.""" + def __reduce__(self) -> tuple[object, ...]: ... diff --git a/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyx b/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyx index 4335fbb41c2..e5f89606330 100644 --- a/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyx +++ b/cuda_core/cuda/core/_memory/_pinned_memory_resource.pyx @@ -5,9 +5,11 @@ from __future__ import annotations from cuda.bindings cimport cydriver -from cuda.core._memory._memory_pool cimport _MemPool, MP_init_create_pool, MP_init_current_pool +from cuda.core._memory._buffer cimport Buffer +from cuda.core._memory._memory_pool cimport _MemPool, _MP_allocate, MP_init_create_pool, MP_init_current_pool from cuda.core._memory cimport _ipc from cuda.core._memory._ipc cimport IPCAllocationHandle +from cuda.core._stream cimport Stream, Stream_accept from cuda.core._utils.cuda_utils cimport ( check_or_create_options, HANDLE_RETURN, @@ -20,6 +22,11 @@ import uuid from cuda.core._utils.cuda_utils import check_multiprocessing_start_method +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from cuda.core.graph import GraphBuilder + __all__ = ['PinnedMemoryResource', 'PinnedMemoryResourceOptions'] @@ -78,6 +85,14 @@ cdef class PinnedMemoryResource(_MemPool): Notes ----- + The device associated with ``stream`` must support host memory pools. If + ``numa_id`` is set or derived for IPC, it must support host NUMA memory pools. + You can query these capabilities through + ``Device.properties.host_memory_pools_supported`` and + ``Device.properties.host_numa_memory_pools_supported``. If the required pool + is unsupported and stream-ordered allocation is not needed, use + :class:`LegacyPinnedMemoryResource`. + To create an IPC-Enabled memory resource (MR) that is capable of sharing allocations between processes, specify ``ipc_enabled=True`` in the initializer option. When IPC is enabled and ``numa_id`` is not specified, the NUMA node @@ -91,6 +106,26 @@ cdef class PinnedMemoryResource(_MemPool): def __init__(self, options: PinnedMemoryResourceOptions | dict[str, object] | None = None) -> None: _PMR_init(self, options) + def allocate(self, size_t size, *, stream: Stream | GraphBuilder) -> Buffer: + """Allocate a host-pinned buffer asynchronously on the supplied stream.""" + if self.is_mapped: + raise TypeError("Cannot allocate from a mapped IPC-enabled memory resource") + cdef Stream s = Stream_accept(stream) + device = s.device + cdef bint supported = ( + device.properties.host_numa_memory_pools_supported + if self._numa_id >= 0 + else device.properties.host_memory_pools_supported + ) + + if not supported: + raise RuntimeError( + f"CUDA device {device.device_id} does not support the requested " + "host memory pool for PinnedMemoryResource. Use " + "LegacyPinnedMemoryResource if memory-pool features are not required." + ) + return _MP_allocate(self, size, s) + def __reduce__(self) -> tuple[object, ...]: return PinnedMemoryResource.from_registry, (self.uuid,) diff --git a/cuda_core/tests/test_device.py b/cuda_core/tests/test_device.py index 4cbd28398f3..0d2e5e00952 100644 --- a/cuda_core/tests/test_device.py +++ b/cuda_core/tests/test_device.py @@ -9,7 +9,7 @@ from cuda.bindings import driver, runtime from cuda.core import Device from cuda.core._utils.cuda_utils import ComputeCapability, handle_return -from cuda.core._utils.version import binding_version, driver_version +from cuda.core._utils.version import driver_version def test_device_init_disabled(): @@ -299,9 +299,7 @@ def test_arch(): ("only_partial_host_native_atomic_supported", bool), ] -version = binding_version() -if version >= (13, 0, 0): - cuda_base_properties += cuda_13_properties +cuda_base_properties += cuda_13_properties @pytest.mark.parametrize("property_name, expected_type", cuda_base_properties) @@ -315,16 +313,8 @@ def test_device_properties_complete(): live_props = {attr for attr in dir(device.properties) if not attr.startswith("_")} tab_props = {attr for attr, _ in cuda_base_properties} - excluded_props = set() - # Exclude CUDA 13+ specific properties when not available - if version < (13, 0, 0): - excluded_props.update({prop[0] for prop in cuda_13_properties}) - - filtered_tab_props = tab_props - excluded_props - filtered_live_props = live_props - excluded_props - - assert len(filtered_tab_props) == len(cuda_base_properties) # Ensure no duplicates. - assert filtered_tab_props == filtered_live_props # Ensure exact match. + assert len(tab_props) == len(cuda_base_properties) # Ensure no duplicates. + assert tab_props == live_props # Ensure exact match. # ============================================================================ diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index 6af4d025b03..a4ea2ee01c4 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -751,6 +751,26 @@ def test_pinned_memory_resource_initialization(init_cuda): buffer.close() +@pytest.mark.agent_authored(model="cursor-grok-4.5") +def test_pinned_memory_resource_rejects_unsupported_host_pool(init_cuda): + """allocate() must fail on devices without host memory pool support (see #2486).""" + device = init_cuda + if device.properties.host_memory_pools_supported: + pytest.skip("Device supports host memory pools") + + try: + mr = PinnedMemoryResource(PinnedMemoryResourceOptions(max_size=POOL_SIZE)) + except CUDAError as exc: + if "CUDA_ERROR_NOT_SUPPORTED" in str(exc): + pytest.skip("PinnedMemoryResource is not supported on this platform/device") + raise + try: + with pytest.raises(RuntimeError, match="does not support.*LegacyPinnedMemoryResource"): + mr.allocate(1024, stream=device.default_stream) + finally: + mr.close() + + def test_managed_memory_resource_initialization(init_cuda): device = Device() skip_if_managed_memory_unsupported(device) From 83b2de7fe711b136d91dd8f243efdbaf71338b6b Mon Sep 17 00:00:00 2001 From: Shaurya Singh Date: Fri, 7 Aug 2026 13:38:36 -0700 Subject: [PATCH 43/50] cuda.core: report host accessibility for NUMA-located VMM resources (#2503) `VirtualMemoryResource.__init__` classifies "host", "host_numa" and "host_numa_current" all as host-located (it clears `self.device` for each), but `is_host_accessible` compared with `== "host"`. A resource configured with `location_type="host_numa"` or `"host_numa_current"` therefore reported `is_host_accessible is False` *and* `is_device_accessible is False` -- an impossible answer that propagates to `Buffer.is_host_accessible`, which forwards to the memory resource. Share a single `_HOST_LOCATION_TYPES` set between the constructor and the property so the two classifications cannot drift again. --- .../core/_memory/_virtual_memory_resource.py | 15 ++++++++++++--- cuda_core/tests/test_memory.py | 17 +++++++++++++++++ 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/cuda_core/cuda/core/_memory/_virtual_memory_resource.py b/cuda_core/cuda/core/_memory/_virtual_memory_resource.py index 74f0f347769..7cd12f597a6 100644 --- a/cuda_core/cuda/core/_memory/_virtual_memory_resource.py +++ b/cuda_core/cuda/core/_memory/_virtual_memory_resource.py @@ -33,6 +33,16 @@ __all__ = ["VirtualMemoryResource", "VirtualMemoryResourceOptions"] +# Location types whose physical backing lives in host memory. Shared by +# VirtualMemoryResource.__init__ and is_host_accessible so the two cannot drift. +_HOST_LOCATION_TYPES = frozenset( + { + VirtualMemoryLocationType.HOST, + VirtualMemoryLocationType.HOST_NUMA, + VirtualMemoryLocationType.HOST_NUMA_CURRENT, + } +) + @dataclass class VirtualMemoryResourceOptions: @@ -169,8 +179,7 @@ def __init__(self, device_id: Device | int, config: VirtualMemoryResourceOptions self.config: VirtualMemoryResourceOptions = check_or_create_options( # type: ignore[assignment] VirtualMemoryResourceOptions, config, "VirtualMemoryResource options", keep_none=False ) - # Matches ("host", "host_numa", "host_numa_current") - if "host" in self.config.location_type: + if self.config.location_type in _HOST_LOCATION_TYPES: self.device = None if not self.device and self.config.location_type == "device": @@ -609,7 +618,7 @@ def is_host_accessible(self) -> bool: """ Indicates whether the allocated memory is accessible from the host. """ - return self.config.location_type == "host" + return self.config.location_type in _HOST_LOCATION_TYPES @property def device_id(self) -> int: diff --git a/cuda_core/tests/test_memory.py b/cuda_core/tests/test_memory.py index a4ea2ee01c4..8d86fa32432 100644 --- a/cuda_core/tests/test_memory.py +++ b/cuda_core/tests/test_memory.py @@ -1875,6 +1875,23 @@ def test_vmm_options_handle_type_win32_raises(): VirtualMemoryResourceOptions._handle_type_to_driver("win32") +@pytest.mark.agent_authored(model="claude-opus-5") +@pytest.mark.parametrize("location_type", ["host", "host_numa", "host_numa_current"]) +def test_vmm_host_location_types_report_host_accessible(location_type): + """Every host-backed location type reports is_host_accessible. + + __init__ classifies "host", "host_numa" and "host_numa_current" alike when + deciding the resource is not bound to a device, so is_host_accessible must + agree; otherwise a NUMA-located resource claims to be neither host- nor + device-accessible. + """ + device = Device() + device.set_current() + mr = VirtualMemoryResource(device, config=VirtualMemoryResourceOptions(location_type=location_type)) + assert mr.device is None + assert mr.is_host_accessible is True + + def test_device_memory_resource_peer_accessible_by_non_owned(mempool_device): """peer_accessible_by on a non-owned (default) DMR queries the driver live.""" dev = mempool_device From 0e6d2825423a6a908abac964569609774c1e8ce3 Mon Sep 17 00:00:00 2001 From: Andy Jost Date: Fri, 7 Aug 2026 13:38:43 -0700 Subject: [PATCH 44/50] cuda.core: validate ctypes host callback signatures against CUhostFn (#2525) * cuda.core: validate ctypes host callback signatures against CUhostFn Reject incompatible ctypes prototypes before CUDA sees them, document the required ABI, and note the stronger checking in the 1.2.0 release notes. * cuda.core: make ctypes flag lookups stubgen/mypy-friendly Use getattr for private ctypes calling-convention constants so the regenerated _host_callback.pyi type-checks cleanly. * cuda.core: check host callback prototypes via public ctypes attributes The previous check inspected ctypes' private _flags_ bits to identify the calling convention. That is wrong on Windows: CPython defines FUNCFLAG_STDCALL as 0, so a bitwise test can never match WINFUNCTYPE, and every win-64 test job rejected a valid callback. The 0x2 fallback used when _ctypes.FUNCFLAG_STDCALL is absent is FUNCFLAG_HRESULT, not stdcall. Drop the calling-convention check rather than repair the bit arithmetic. ctypes only honors stdcall when building a callback on 32-bit x86 Windows, which cuda.core does not support, and FUNCFLAG_PYTHONAPI is never consulted on the callback path, so CFUNCTYPE, WINFUNCTYPE, and PYFUNCTYPE all yield the same FFI_DEFAULT_ABI thunk. That leaves the declared result and argument types, which are reachable through the public restype/argtypes attributes. Reading those public attributes also lets a function pointer taken from a shared library be accepted once its restype and argtypes are declared, which the class-level lookup could never see. --- cuda_core/cuda/core/graph/_graph_builder.pyi | 18 +++- cuda_core/cuda/core/graph/_graph_builder.pyx | 18 +++- cuda_core/cuda/core/graph/_graph_node.pyi | 18 +++- cuda_core/cuda/core/graph/_graph_node.pyx | 18 +++- cuda_core/cuda/core/graph/_host_callback.pyi | 18 +++- cuda_core/cuda/core/graph/_host_callback.pyx | 42 ++++++++++ cuda_core/cuda/core/graph/_subclasses.pyi | 9 ++ cuda_core/cuda/core/graph/_subclasses.pyx | 9 ++ cuda_core/docs/source/release/1.2.0-notes.rst | 14 ++++ cuda_core/tests/graph/test_graph_builder.py | 15 ++++ .../tests/graph/test_graph_definition.py | 84 +++++++++++++++++++ 11 files changed, 246 insertions(+), 17 deletions(-) diff --git a/cuda_core/cuda/core/graph/_graph_builder.pyi b/cuda_core/cuda/core/graph/_graph_builder.pyi index 6689082b10b..d238b419be1 100644 --- a/cuda_core/cuda/core/graph/_graph_builder.pyi +++ b/cuda_core/cuda/core/graph/_graph_builder.pyi @@ -409,10 +409,12 @@ class GraphBuilder: - **Python callable**: Pass any callable. The GIL is acquired automatically. The callable must take no arguments; use closures or ``functools.partial`` to bind state. - - **ctypes function pointer**: Pass a ``ctypes.CFUNCTYPE`` instance. - The function receives a single ``void*`` argument (the - ``user_data``). The caller must keep the ctypes wrapper alive - for the lifetime of the graph. + - **ctypes function pointer**: The function receives a single + ``void*`` argument (the ``user_data``), and the caller must keep + the ctypes wrapper alive for the lifetime of the graph. Its + declared prototype must match the driver's ``CUhostFn`` + (``void (*)(void*)``): ``ctypes.CFUNCTYPE(None, ctypes.c_void_p)``, + or ``ctypes.WINFUNCTYPE(None, ctypes.c_void_p)`` on Windows. .. warning:: @@ -432,6 +434,14 @@ class GraphBuilder: Only for ctypes function pointers. If ``int``, passed as a raw pointer (caller manages lifetime). If bytes-like, the data is copied and its lifetime is tied to the graph. + + Raises + ------ + TypeError + If ``fn`` is a ctypes function pointer whose declared prototype + does not match ``CUhostFn``. + ValueError + If ``user_data`` is given for a Python callable. """ class Graph: diff --git a/cuda_core/cuda/core/graph/_graph_builder.pyx b/cuda_core/cuda/core/graph/_graph_builder.pyx index 1115e3023df..d3053a7261e 100644 --- a/cuda_core/cuda/core/graph/_graph_builder.pyx +++ b/cuda_core/cuda/core/graph/_graph_builder.pyx @@ -860,10 +860,12 @@ cdef class GraphBuilder: - **Python callable**: Pass any callable. The GIL is acquired automatically. The callable must take no arguments; use closures or ``functools.partial`` to bind state. - - **ctypes function pointer**: Pass a ``ctypes.CFUNCTYPE`` instance. - The function receives a single ``void*`` argument (the - ``user_data``). The caller must keep the ctypes wrapper alive - for the lifetime of the graph. + - **ctypes function pointer**: The function receives a single + ``void*`` argument (the ``user_data``), and the caller must keep + the ctypes wrapper alive for the lifetime of the graph. Its + declared prototype must match the driver's ``CUhostFn`` + (``void (*)(void*)``): ``ctypes.CFUNCTYPE(None, ctypes.c_void_p)``, + or ``ctypes.WINFUNCTYPE(None, ctypes.c_void_p)`` on Windows. .. warning:: @@ -883,6 +885,14 @@ cdef class GraphBuilder: Only for ctypes function pointers. If ``int``, passed as a raw pointer (caller manages lifetime). If bytes-like, the data is copied and its lifetime is tied to the graph. + + Raises + ------ + TypeError + If ``fn`` is a ctypes function pointer whose declared prototype + does not match ``CUhostFn``. + ValueError + If ``user_data`` is given for a Python callable. """ GB_callback(self, fn, user_data, False) diff --git a/cuda_core/cuda/core/graph/_graph_node.pyi b/cuda_core/cuda/core/graph/_graph_node.pyi index ab503183f63..0e3cac045d2 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyi +++ b/cuda_core/cuda/core/graph/_graph_node.pyi @@ -333,10 +333,12 @@ class GraphNode: - **Python callable**: Pass any callable. The GIL is acquired automatically. The callable must take no arguments; use closures or ``functools.partial`` to bind state. - - **ctypes function pointer**: Pass a ``ctypes.CFUNCTYPE`` instance. - The function receives a single ``void*`` argument (the - ``user_data``). The caller must keep the ctypes wrapper alive - for the lifetime of the graph. + - **ctypes function pointer**: The function receives a single + ``void*`` argument (the ``user_data``), and the caller must keep + the ctypes wrapper alive for the lifetime of the graph. Its + declared prototype must match the driver's ``CUhostFn`` + (``void (*)(void*)``): ``ctypes.CFUNCTYPE(None, ctypes.c_void_p)``, + or ``ctypes.WINFUNCTYPE(None, ctypes.c_void_p)`` on Windows. .. warning:: @@ -361,6 +363,14 @@ class GraphNode: ------- HostCallbackNode A new HostCallbackNode representing the callback. + + Raises + ------ + TypeError + If ``fn`` is a ctypes function pointer whose declared prototype + does not match ``CUhostFn``. + ValueError + If ``user_data`` is given for a Python callable. """ def if_then(self, condition: GraphCondition) -> IfNode: diff --git a/cuda_core/cuda/core/graph/_graph_node.pyx b/cuda_core/cuda/core/graph/_graph_node.pyx index 37411c857b5..2c9c07e6b3a 100644 --- a/cuda_core/cuda/core/graph/_graph_node.pyx +++ b/cuda_core/cuda/core/graph/_graph_node.pyx @@ -490,10 +490,12 @@ cdef class GraphNode: - **Python callable**: Pass any callable. The GIL is acquired automatically. The callable must take no arguments; use closures or ``functools.partial`` to bind state. - - **ctypes function pointer**: Pass a ``ctypes.CFUNCTYPE`` instance. - The function receives a single ``void*`` argument (the - ``user_data``). The caller must keep the ctypes wrapper alive - for the lifetime of the graph. + - **ctypes function pointer**: The function receives a single + ``void*`` argument (the ``user_data``), and the caller must keep + the ctypes wrapper alive for the lifetime of the graph. Its + declared prototype must match the driver's ``CUhostFn`` + (``void (*)(void*)``): ``ctypes.CFUNCTYPE(None, ctypes.c_void_p)``, + or ``ctypes.WINFUNCTYPE(None, ctypes.c_void_p)`` on Windows. .. warning:: @@ -518,6 +520,14 @@ cdef class GraphNode: ------- HostCallbackNode A new HostCallbackNode representing the callback. + + Raises + ------ + TypeError + If ``fn`` is a ctypes function pointer whose declared prototype + does not match ``CUhostFn``. + ValueError + If ``user_data`` is given for a Python callable. """ return GN_callback(self, fn, user_data) diff --git a/cuda_core/cuda/core/graph/_host_callback.pyi b/cuda_core/cuda/core/graph/_host_callback.pyi index 6c9d0ead317..1c642abf501 100644 --- a/cuda_core/cuda/core/graph/_host_callback.pyi +++ b/cuda_core/cuda/core/graph/_host_callback.pyi @@ -1,3 +1,19 @@ # This file was generated by stubgen-pyx v0.2.6 from cuda_core/cuda/core/graph/_host_callback.pyx -from __future__ import annotations \ No newline at end of file +from __future__ import annotations + +import sys + +_CUHOSTFN_HINT = 'ctypes.CFUNCTYPE(None, ctypes.c_void_p)' if sys.platform != 'win32' else 'ctypes.CFUNCTYPE(None, ctypes.c_void_p) or ctypes.WINFUNCTYPE(None, ctypes.c_void_p)' + +def _cuhostfn_type_error(detail): + """Build the rejection message for a non-conforming ctypes callback.""" + +def _validate_ctypes_host_callback(fn): + """Reject ctypes callbacks whose declared prototype is not CUhostFn. + + ``restype`` and ``argtypes`` are the prototype the caller declared, and are + what CUDA calls through. A function pointer taken from a shared library + keeps ctypes' defaults -- a ``c_int`` result and unspecified arguments -- + until the caller declares otherwise, so it must be declared to be accepted. + """ \ No newline at end of file diff --git a/cuda_core/cuda/core/graph/_host_callback.pyx b/cuda_core/cuda/core/graph/_host_callback.pyx index 5fd71f8653f..4fb48f0d6ec 100644 --- a/cuda_core/cuda/core/graph/_host_callback.pyx +++ b/cuda_core/cuda/core/graph/_host_callback.pyx @@ -14,9 +14,47 @@ from cuda.core._resource_handles cimport ( make_opaque_py, ) +import sys import ctypes as ct +# CUhostFn is `void (CUDA_CB *)(void*)`. CUDA_CB is __stdcall on Windows and +# empty elsewhere, but ctypes only honors that distinction when it builds a +# callback on 32-bit x86 Windows, which cuda.core does not support: on win-64 +# and ARM64 both CFUNCTYPE and WINFUNCTYPE produce a FFI_DEFAULT_ABI thunk. The +# declared result and argument types are all that remain worth checking. +_CUHOSTFN_HINT = ( + "ctypes.CFUNCTYPE(None, ctypes.c_void_p)" + if sys.platform != "win32" + else "ctypes.CFUNCTYPE(None, ctypes.c_void_p) or " + "ctypes.WINFUNCTYPE(None, ctypes.c_void_p)" +) + + +def _cuhostfn_type_error(detail): + """Build the rejection message for a non-conforming ctypes callback.""" + return TypeError( + f"host callback {detail}; CUDA requires a callback matching CUhostFn " + f"(void (*)(void*)), declared as {_CUHOSTFN_HINT}. " + "Alternatively, pass a Python callable." + ) + + +def _validate_ctypes_host_callback(fn): + """Reject ctypes callbacks whose declared prototype is not CUhostFn. + + ``restype`` and ``argtypes`` are the prototype the caller declared, and are + what CUDA calls through. A function pointer taken from a shared library + keeps ctypes' defaults -- a ``c_int`` result and unspecified arguments -- + until the caller declares otherwise, so it must be declared to be accepted. + """ + restype = fn.restype + argtypes = fn.argtypes + if restype is not None or argtypes is None or tuple(argtypes) != (ct.c_void_p,): + raise _cuhostfn_type_error( + f"has prototype restype={restype!r}, argtypes={argtypes!r}") + + cdef void _py_host_trampoline(void* data) noexcept with gil: (data)() @@ -36,8 +74,12 @@ cdef void _resolve_host_callback( ``cuGraphAddHostNode`` or ``cuLaunchHostFunc``. ``*out_fn_owner`` owns the callback object; ``*out_data_owner`` owns a copied ``user_data`` buffer and is left null otherwise. The caller attaches both owners to the graph node. + + ctypes callbacks are validated against the ``CUhostFn`` ABI before their + address is passed to CUDA. """ if isinstance(fn, ct._CFuncPtr): + _validate_ctypes_host_callback(fn) out_fn[0] = ct.cast(fn, ct.c_void_p).value if user_data is None: out_user_data[0] = NULL diff --git a/cuda_core/cuda/core/graph/_subclasses.pyi b/cuda_core/cuda/core/graph/_subclasses.pyi index ebe0adb01c9..a68e500f7f2 100644 --- a/cuda_core/cuda/core/graph/_subclasses.pyi +++ b/cuda_core/cuda/core/graph/_subclasses.pyi @@ -320,6 +320,11 @@ class HostCallbackNode(GraphNode): def update(self, fn, *, user_data=None) -> None: """Replace the callback and user-data binding for this node. + ``fn`` accepts the same forms as :meth:`~graph.GraphNode.callback`: a + Python callable, or a ctypes function pointer whose declared prototype + matches ``CUhostFn`` (``void (*)(void*)``). A mismatched ctypes + prototype raises ``TypeError``. + .. warning:: Callbacks must not call CUDA API functions. Doing so may @@ -508,6 +513,10 @@ class ExecutableHostCallbackNode(ExecutableGraphNode): def update(self, fn, *, user_data=None) -> None: """Replace the callback and user-data binding for future launches. + ``fn`` may be a Python callable, or a ctypes function pointer whose + declared prototype matches ``CUhostFn`` (``void (*)(void*)``); a + mismatched prototype raises ``TypeError``. + .. warning:: Callbacks must not call CUDA API functions. Doing so may deadlock diff --git a/cuda_core/cuda/core/graph/_subclasses.pyx b/cuda_core/cuda/core/graph/_subclasses.pyx index b0630165671..79e302d59d5 100644 --- a/cuda_core/cuda/core/graph/_subclasses.pyx +++ b/cuda_core/cuda/core/graph/_subclasses.pyx @@ -1172,6 +1172,11 @@ cdef class HostCallbackNode(GraphNode): def update(self, fn, *, user_data=None) -> None: """Replace the callback and user-data binding for this node. + ``fn`` accepts the same forms as :meth:`~graph.GraphNode.callback`: a + Python callable, or a ctypes function pointer whose declared prototype + matches ``CUhostFn`` (``void (*)(void*)``). A mismatched ctypes + prototype raises ``TypeError``. + .. warning:: Callbacks must not call CUDA API functions. Doing so may @@ -1603,6 +1608,10 @@ cdef class ExecutableHostCallbackNode(ExecutableGraphNode): def update(self, fn, *, user_data=None) -> None: """Replace the callback and user-data binding for future launches. + ``fn`` may be a Python callable, or a ctypes function pointer whose + declared prototype matches ``CUhostFn`` (``void (*)(void*)``); a + mismatched prototype raises ``TypeError``. + .. warning:: Callbacks must not call CUDA API functions. Doing so may deadlock diff --git a/cuda_core/docs/source/release/1.2.0-notes.rst b/cuda_core/docs/source/release/1.2.0-notes.rst index ffd82331f39..120d2c2a253 100644 --- a/cuda_core/docs/source/release/1.2.0-notes.rst +++ b/cuda_core/docs/source/release/1.2.0-notes.rst @@ -59,6 +59,20 @@ Fixes and enhancements (`#2517 `__, closes `#2516 `__) +- ``cuda.core`` now checks ctypes host callbacks against the driver's + ``CUhostFn`` signature (``void (*)(void*)``) before passing the function + pointer to CUDA. :meth:`graph.GraphNode.callback`, + :meth:`graph.GraphBuilder.callback`, and the host-callback ``update()`` + methods raise ``TypeError`` for a mismatched prototype, rather than leaving + the driver to call through an incompatible signature, which is undefined + behavior. Declarations that previously reached the driver, such as + ``ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p)``, are now rejected at the + call site. A function pointer obtained from a shared library keeps ctypes' + default ``c_int`` result type until it is declared, so set its ``restype`` + and ``argtypes`` (or cast it to the prototype above) before passing it. On + Windows, both ``ctypes.CFUNCTYPE`` and ``ctypes.WINFUNCTYPE`` are accepted. + (`#2439 `__) + Deprecation Notices ------------------- diff --git a/cuda_core/tests/graph/test_graph_builder.py b/cuda_core/tests/graph/test_graph_builder.py index 6c7c9ef7d64..a730c2bd83a 100644 --- a/cuda_core/tests/graph/test_graph_builder.py +++ b/cuda_core/tests/graph/test_graph_builder.py @@ -306,6 +306,21 @@ def read_byte(data): assert result[0] == 0xAB +@pytest.mark.agent_authored(model="cursor-grok-4.5") +def test_graph_capture_callback_ctypes_rejects_incompatible_signature(init_cuda): + """Stream-capture host callbacks use the same ctypes ABI check.""" + import ctypes + + bad_type = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p) + launch_stream = Device().create_stream() + gb = launch_stream.create_graph_builder().begin_building() + try: + with pytest.raises(TypeError, match="CUhostFn"): + gb.callback(bad_type(0)) + finally: + gb.end_building() + + @pytest.mark.agent_authored(model="claude-opus-4.8") def test_graph_capture_callback_python_survives_del(init_cuda): """Captured callback is retained by its graph-node user object after del.""" diff --git a/cuda_core/tests/graph/test_graph_definition.py b/cuda_core/tests/graph/test_graph_definition.py index 9459cfb4e95..0aeb5a9d527 100644 --- a/cuda_core/tests/graph/test_graph_definition.py +++ b/cuda_core/tests/graph/test_graph_definition.py @@ -3,6 +3,8 @@ """Tests for GraphDefinition topology, node types, instantiation, and execution.""" +import ctypes +import sys from collections.abc import Callable from dataclasses import dataclass, field @@ -1159,6 +1161,88 @@ def test_host_callback_user_data_rejected_for_python_callable(sample_graphdef): sample_graphdef.callback(lambda: None, user_data=b"hello") +_INCOMPATIBLE_CTYPES_HOST_CALLBACKS = [ + pytest.param(ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p), id="bad-restype"), + pytest.param(ctypes.CFUNCTYPE(None, ctypes.c_int), id="bad-argtype"), + pytest.param(ctypes.CFUNCTYPE(None), id="missing-arg"), + pytest.param(ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p), id="extra-arg"), +] + +# Prototypes that declare CUhostFn but differ in ctypes bookkeeping. ctypes +# builds the same thunk for all of them, so all must be accepted. +_COMPATIBLE_CTYPES_HOST_CALLBACKS = [ + pytest.param(ctypes.CFUNCTYPE(None, ctypes.c_void_p), id="cfunctype"), + pytest.param(ctypes.CFUNCTYPE(None, ctypes.c_void_p, use_errno=True), id="use-errno"), + pytest.param(ctypes.PYFUNCTYPE(None, ctypes.c_void_p), id="pyfunctype"), +] + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +@pytest.mark.parametrize("callback_type", _INCOMPATIBLE_CTYPES_HOST_CALLBACKS) +def test_host_callback_ctypes_rejects_incompatible_signature(sample_graphdef, callback_type): + """Incompatible ctypes prototypes are rejected before CUDA sees them.""" + with pytest.raises(TypeError, match="CUhostFn"): + sample_graphdef.callback(callback_type(0)) + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +def test_host_callback_ctypes_update_rejects_incompatible_signature(sample_graphdef): + """HostCallbackNode.update applies the same ctypes ABI check.""" + good_type = ctypes.CFUNCTYPE(None, ctypes.c_void_p) + bad_type = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p) + + @good_type + def good(data): + pass + + node = sample_graphdef.callback(good) + with pytest.raises(TypeError, match="CUhostFn"): + node.update(bad_type(0)) + + +@pytest.mark.agent_authored(model="claude-opus-5") +@pytest.mark.parametrize("callback_type", _COMPATIBLE_CTYPES_HOST_CALLBACKS) +def test_host_callback_ctypes_accepts_equivalent_prototypes(sample_graphdef, callback_type): + """Prototypes that declare CUhostFn are accepted and run.""" + called = [False] + + @callback_type + def raw_fn(data): + called[0] = True + + sample_graphdef.callback(raw_fn) + graph = sample_graphdef.instantiate() + + stream = Device().create_stream() + graph.upload(stream) + graph.launch(stream) + stream.sync() + + assert called[0] + + +@pytest.mark.agent_authored(model="cursor-grok-4.5") +@pytest.mark.skipif(sys.platform != "win32", reason="WINFUNCTYPE is Windows-only") +def test_host_callback_ctypes_accepts_winfunctype(sample_graphdef): + """On Windows, WINFUNCTYPE matches CUDA_CB (__stdcall) and is accepted.""" + callback_type = ctypes.WINFUNCTYPE(None, ctypes.c_void_p) + called = [False] + + @callback_type + def raw_fn(data): + called[0] = True + + sample_graphdef.callback(raw_fn) + graph = sample_graphdef.instantiate() + + stream = Device().create_stream() + graph.upload(stream) + graph.launch(stream) + stream.sync() + + assert called[0] + + def test_instantiate_and_execute_event_record_wait(sample_graphdef): """Graph with event record and wait nodes can be executed.""" event = Device().create_event() From be1e7524a2d27bbef48569987930c38fbc994f5e Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Fri, 7 Aug 2026 14:30:24 -0700 Subject: [PATCH 45/50] chore: avoid some warnings when running cuda.core tests (#2515) --- cuda_core/pytest.ini | 4 +++- cuda_core/tests/system/test_system_device.py | 4 ++++ cuda_core/tests/test_object_protocols.py | 4 ++-- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/cuda_core/pytest.ini b/cuda_core/pytest.ini index c3d243387fe..dcb7cc84929 100644 --- a/cuda_core/pytest.ini +++ b/cuda_core/pytest.ini @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # # SPDX-License-Identifier: Apache-2.0 @@ -11,3 +11,5 @@ markers = agent_authored(model): agent-authored test not yet materially human-reviewed human_reviewed: agent-authored test materially reviewed or rewritten by a human human_authored: test authored primarily by a human + thread_unsafe(reason): test is not safe to run concurrently with other tests (e.g. uses mocks, patches globals, or mutates shared CUDA state) + parallel_threads_limit(n): cap the number of parallel threads pytest-run-parallel uses for this test or module diff --git a/cuda_core/tests/system/test_system_device.py b/cuda_core/tests/system/test_system_device.py index 3b2131548b9..8fa41da0488 100644 --- a/cuda_core/tests/system/test_system_device.py +++ b/cuda_core/tests/system/test_system_device.py @@ -684,6 +684,7 @@ def test_cooler(): assert all(isinstance(t, typing.CoolerTarget) for t in target) +@pytest.mark.filterwarnings("ignore::DeprecationWarning") def test_temperature(): for device in system.Device.get_all_devices(): temperature = device.temperature @@ -695,6 +696,9 @@ def test_temperature(): # By docs, should be supported on KEPLER or newer, but experimentally, # is also unsupported on other hardware. + # get_threshold emits DeprecationWarning for some thresholds on Ada+; + # that behaviour is tested separately in + # test_temperature_threshold_unrecognized_device_arch. with unsupported_before(device, None): for threshold in list(typing.TemperatureThresholds): t = temperature.get_threshold(threshold) diff --git a/cuda_core/tests/test_object_protocols.py b/cuda_core/tests/test_object_protocols.py index e01f7a86941..baf790abea8 100644 --- a/cuda_core/tests/test_object_protocols.py +++ b/cuda_core/tests/test_object_protocols.py @@ -750,7 +750,7 @@ def test_hash_distinct_same_type(a_name, b_name, request): assert hash(obj_a) != hash(obj_b) # extremely unlikely -@pytest.mark.parametrize("a_name,b_name", itertools.combinations(HASH_TYPES, 2)) +@pytest.mark.parametrize("a_name,b_name", list(itertools.combinations(HASH_TYPES, 2))) def test_hash_distinct_cross_type(a_name, b_name, request): """Distinct objects of different types have different hashes.""" obj_a = request.getfixturevalue(a_name) @@ -774,7 +774,7 @@ def test_equality_basic(fixture_name, request): assert obj != obj.handle -@pytest.mark.parametrize("a_name,b_name", itertools.combinations(EQ_TYPES, 2)) +@pytest.mark.parametrize("a_name,b_name", list(itertools.combinations(EQ_TYPES, 2))) def test_no_cross_type_equality(a_name, b_name, request): """No two distinct objects of different types should compare equal.""" obj_a = request.getfixturevalue(a_name) From 1f9e9a44bb41915d399f2d2189e50d9c56038397 Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Fri, 7 Aug 2026 15:40:35 -0700 Subject: [PATCH 46/50] ci: constrain internal builds to exact local wheels (#2510) * ci: constrain internal builds to exact local wheels * ci: keep CI tool tests in nightly workflow * ci: generate local wheel constraints in workflows --- .github/workflows/build-wheel.yml | 82 +++++++++++++++++-- .github/workflows/coverage.yml | 100 +++++++++++++++++------ .github/workflows/test-sdist-linux.yml | 34 +++++++- .github/workflows/test-sdist-windows.yml | 40 +++++++-- 4 files changed, 217 insertions(+), 39 deletions(-) diff --git a/.github/workflows/build-wheel.yml b/.github/workflows/build-wheel.yml index 68f2801fb60..c089cb1c3f7 100644 --- a/.github/workflows/build-wheel.yml +++ b/.github/workflows/build-wheel.yml @@ -150,6 +150,19 @@ jobs: run: | twine check --strict cuda_pathfinder/*.whl + - name: Constrain builds to the local cuda.pathfinder wheel + run: | + pathfinder_wheels=(cuda_pathfinder/cuda_pathfinder-*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + mkdir -p wheel-constraints + if [[ "${{ inputs.host-platform }}" == win* ]]; then + pathfinder_uri="file:///$(cygpath -am "${pathfinder_wheels[0]}")" + else + pathfinder_uri="file:///host$(realpath "${pathfinder_wheels[0]}")" + fi + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" | tee wheel-constraints/cuda-bindings.txt + - name: Upload cuda.pathfinder build artifacts if: ${{ strategy.job-index == 0 && inputs.host-platform == 'linux-64' }} uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 @@ -172,6 +185,8 @@ jobs: output-dir: ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }} env: CIBW_BUILD: ${{ env.CIBW_BUILD }} + CIBW_BEFORE_BUILD_LINUX: 'python -m pip install --upgrade "pip>=25.3"' + CIBW_BEFORE_BUILD_WINDOWS: 'python -m pip install --upgrade "pip>=25.3" delvewheel' # TODO: remove cpython-prerelease once 3.15 is officially supported # Allow CPython pre-release builds (currently 3.15 / 3.15t). This is a # no-op for stable Python versions because CIBW_BUILD still filters @@ -181,6 +196,8 @@ jobs: CIBW_ENVIRONMENT_LINUX: > CUDA_PATH=/host/${{ env.CUDA_PATH }} CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }} + PIP_BUILD_CONSTRAINT=/host/${{ github.workspace }}/wheel-constraints/cuda-bindings.txt + PIP_CONSTRAINT=/host/${{ github.workspace }}/wheel-constraints/cuda-bindings.txt CC="/host/${{ env.SCCACHE_PATH }} cc" CXX="/host/${{ env.SCCACHE_PATH }} c++" SCCACHE_GHA_ENABLED=true @@ -194,6 +211,8 @@ jobs: CIBW_ENVIRONMENT_WINDOWS: > CUDA_PATH="$(cygpath -w ${{ env.CUDA_PATH }})" CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }} + PIP_BUILD_CONSTRAINT="$(cygpath -w ./wheel-constraints/cuda-bindings.txt)" + PIP_CONSTRAINT="$(cygpath -w ./wheel-constraints/cuda-bindings.txt)" # check cache stats before leaving cibuildwheel CIBW_BEFORE_TEST_LINUX: > "/host/${{ env.SCCACHE_PATH }}" --show-adv-stats && @@ -226,6 +245,27 @@ jobs: run: | twine check --strict ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}/*.whl + - name: Constrain cuda.core to the local cuda.bindings wheel + run: | + pathfinder_wheels=(cuda_pathfinder/cuda_pathfinder-*.whl) + bindings_wheels=("${CUDA_BINDINGS_ARTIFACTS_DIR}"/cuda_bindings-"${BUILD_CUDA_MAJOR}".*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test "${#bindings_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + test -f "${bindings_wheels[0]}" + mkdir -p wheel-constraints + if [[ "${{ inputs.host-platform }}" == win* ]]; then + pathfinder_uri="file:///$(cygpath -am "${pathfinder_wheels[0]}")" + bindings_uri="file:///$(cygpath -am "${bindings_wheels[0]}")" + else + pathfinder_uri="file:///host$(realpath "${pathfinder_wheels[0]}")" + bindings_uri="file:///host$(realpath "${bindings_wheels[0]}")" + fi + { + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" + printf 'cuda-bindings @ %s\n' "${bindings_uri}" + } | tee wheel-constraints/cuda-core.txt + - name: Upload cuda.bindings build artifacts uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: @@ -240,6 +280,8 @@ jobs: output-dir: ${{ env.CUDA_CORE_ARTIFACTS_DIR }} env: CIBW_BUILD: ${{ env.CIBW_BUILD }} + CIBW_BEFORE_BUILD_LINUX: 'python -m pip install --upgrade "pip>=25.3"' + CIBW_BEFORE_BUILD_WINDOWS: 'python -m pip install --upgrade "pip>=25.3" delvewheel' # TODO: remove cpython-prerelease once 3.15 is officially supported # Allow CPython pre-release builds (currently 3.15 / 3.15t). This is a # no-op for stable Python versions because CIBW_BUILD still filters @@ -250,7 +292,8 @@ jobs: CUDA_PATH=/host/${{ env.CUDA_PATH }} CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }} CUDA_CORE_BUILD_MAJOR=${{ env.BUILD_CUDA_MAJOR }} - PIP_FIND_LINKS=/host/${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }} + PIP_BUILD_CONSTRAINT=/host/${{ github.workspace }}/wheel-constraints/cuda-core.txt + PIP_CONSTRAINT=/host/${{ github.workspace }}/wheel-constraints/cuda-core.txt CC="/host/${{ env.SCCACHE_PATH }} cc" CXX="/host/${{ env.SCCACHE_PATH }} c++" SCCACHE_GHA_ENABLED=true @@ -265,7 +308,8 @@ jobs: CUDA_PATH="$(cygpath -w ${{ env.CUDA_PATH }})" CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }} CUDA_CORE_BUILD_MAJOR=${{ env.BUILD_CUDA_MAJOR }} - PIP_FIND_LINKS="$(cygpath -w ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }})" + PIP_BUILD_CONSTRAINT="$(cygpath -w ./wheel-constraints/cuda-core.txt)" + PIP_CONSTRAINT="$(cygpath -w ./wheel-constraints/cuda-core.txt)" # check cache stats before leaving cibuildwheel CIBW_BEFORE_TEST_LINUX: > "/host${{ env.SCCACHE_PATH }}" --show-adv-stats && @@ -444,14 +488,36 @@ jobs: OLD_BRANCH=$(yq '.backport_branch' ci/versions.yml) OLD_BASENAME="cuda-bindings-python${PYTHON_VERSION_FORMATTED}-cuda*-${{ inputs.host-platform }}*" LATEST_PRIOR_RUN_ID=$(./ci/tools/lookup-run-id --branch "${OLD_BRANCH}" NVIDIA/cuda-python "CI") + PREV_BINDINGS_DIR="cuda_bindings/dist-prev" gh run download $LATEST_PRIOR_RUN_ID -p ${OLD_BASENAME} -R NVIDIA/cuda-python rm -rf ${OLD_BASENAME}-tests # exclude cython test artifacts ls -al $OLD_BASENAME - mkdir -p "${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}" - mv $OLD_BASENAME/*.whl "${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }}" + mkdir -p "${PREV_BINDINGS_DIR}" + mv $OLD_BASENAME/*.whl "${PREV_BINDINGS_DIR}" rmdir $OLD_BASENAME + - name: Constrain previous cuda.core to the downloaded cuda.bindings wheel + run: | + pathfinder_wheels=(cuda_pathfinder/cuda_pathfinder-*.whl) + bindings_wheels=(cuda_bindings/dist-prev/cuda_bindings-"${BUILD_PREV_CUDA_MAJOR}".*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test "${#bindings_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + test -f "${bindings_wheels[0]}" + mkdir -p wheel-constraints + if [[ "${{ inputs.host-platform }}" == win* ]]; then + pathfinder_uri="file:///$(cygpath -am "${pathfinder_wheels[0]}")" + bindings_uri="file:///$(cygpath -am "${bindings_wheels[0]}")" + else + pathfinder_uri="file:///host$(realpath "${pathfinder_wheels[0]}")" + bindings_uri="file:///host$(realpath "${bindings_wheels[0]}")" + fi + { + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" + printf 'cuda-bindings @ %s\n' "${bindings_uri}" + } | tee wheel-constraints/cuda-core-prev.txt + - name: Build cuda.core wheel uses: pypa/cibuildwheel@4726cd35bb13f7bde50cf2761f2499ac7b3aa32c # v4.1.1 with: @@ -459,6 +525,8 @@ jobs: output-dir: ${{ env.CUDA_CORE_ARTIFACTS_DIR }} env: CIBW_BUILD: ${{ env.CIBW_BUILD }} + CIBW_BEFORE_BUILD_LINUX: 'python -m pip install --upgrade "pip>=25.3"' + CIBW_BEFORE_BUILD_WINDOWS: 'python -m pip install --upgrade "pip>=25.3" delvewheel' # TODO: remove cpython-prerelease once 3.15 is officially supported # Allow CPython pre-release builds (currently 3.15 / 3.15t). This is a # no-op for stable Python versions because CIBW_BUILD still filters @@ -469,7 +537,8 @@ jobs: CUDA_PATH=/host/${{ env.CUDA_PATH }} CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }} CUDA_CORE_BUILD_MAJOR=${{ env.BUILD_PREV_CUDA_MAJOR }} - PIP_FIND_LINKS=/host/${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }} + PIP_BUILD_CONSTRAINT=/host/${{ github.workspace }}/wheel-constraints/cuda-core-prev.txt + PIP_CONSTRAINT=/host/${{ github.workspace }}/wheel-constraints/cuda-core-prev.txt CC="/host/${{ env.SCCACHE_PATH }} cc" CXX="/host/${{ env.SCCACHE_PATH }} c++" SCCACHE_GHA_ENABLED=true @@ -484,7 +553,8 @@ jobs: CUDA_PATH="$(cygpath -w ${{ env.CUDA_PATH }})" CUDA_PYTHON_PARALLEL_LEVEL=${{ env.CUDA_PYTHON_PARALLEL_LEVEL }} CUDA_CORE_BUILD_MAJOR=${{ env.BUILD_PREV_CUDA_MAJOR }} - PIP_FIND_LINKS="$(cygpath -w ${{ env.CUDA_BINDINGS_ARTIFACTS_DIR }})" + PIP_BUILD_CONSTRAINT="$(cygpath -w ./wheel-constraints/cuda-core-prev.txt)" + PIP_CONSTRAINT="$(cygpath -w ./wheel-constraints/cuda-core-prev.txt)" # check cache stats before leaving cibuildwheel CIBW_BEFORE_TEST_LINUX: > "/host${{ env.SCCACHE_PATH }}" --show-adv-stats && diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index ecc90674c78..fc234999fca 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -118,18 +118,51 @@ jobs: run: | python -m venv .venv - - name: Build cuda-pathfinder - run: | - cd cuda_pathfinder - ../.venv/bin/pip install -v . --group test - - - name: Build cuda-bindings - run: | - cd cuda_bindings - ../.venv/bin/pip install -v . --group test - - - name: Build cuda-core - run: | + - name: Install pip with build-constraint support + run: .venv/bin/python -m pip install "pip>=25.3" + + - name: Build and install cuda-pathfinder wheel + run: | + .venv/bin/pip wheel -v --no-deps ./cuda_pathfinder -w ./wheels/ + .venv/bin/pip install -v ./wheels/cuda_pathfinder*.whl --group ./cuda_pathfinder/pyproject.toml:test + + - name: Constrain builds to the local cuda-pathfinder wheel + run: | + pathfinder_wheels=(wheels/cuda_pathfinder-*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + mkdir -p wheel-constraints + pathfinder_uri="file://$(realpath "${pathfinder_wheels[0]}")" + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" | tee wheel-constraints/cuda-bindings.txt + + - name: Build and install cuda-bindings wheel + run: | + export PIP_BUILD_CONSTRAINT="$(pwd)/wheel-constraints/cuda-bindings.txt" + export PIP_CONSTRAINT="${PIP_BUILD_CONSTRAINT}" + .venv/bin/pip wheel -v --no-deps ./cuda_bindings -w ./wheels/ + .venv/bin/pip install -v ./wheels/cuda_bindings*.whl --group ./cuda_bindings/pyproject.toml:test + + - name: Constrain cuda-core to the local cuda-bindings wheel + run: | + CUDA_MAJOR="${CUDA_VER%%.*}" + pathfinder_wheels=(wheels/cuda_pathfinder-*.whl) + bindings_wheels=(wheels/cuda_bindings-"${CUDA_MAJOR}".*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test "${#bindings_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + test -f "${bindings_wheels[0]}" + mkdir -p wheel-constraints + pathfinder_uri="file://$(realpath "${pathfinder_wheels[0]}")" + bindings_uri="file://$(realpath "${bindings_wheels[0]}")" + { + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" + printf 'cuda-bindings @ %s\n' "${bindings_uri}" + } | tee wheel-constraints/cuda-core.txt + + - name: Build and install cuda-core + run: | + export PIP_BUILD_CONSTRAINT="$(pwd)/wheel-constraints/cuda-core.txt" + export PIP_CONSTRAINT="${PIP_BUILD_CONSTRAINT}" cd cuda_core ../.venv/bin/pip install -v . --group test @@ -225,27 +258,48 @@ jobs: run: | python -m venv .venv - - name: Build and install cuda.pathfinder + - name: Build cuda.pathfinder wheel run: | - .venv/Scripts/pip install wheel setuptools Cython + .venv/Scripts/python -m pip install "pip>=25.3" wheel setuptools Cython .venv/Scripts/pip wheel -v --no-deps ./cuda_pathfinder -w ./wheels/ + - name: Constrain builds to the local cuda.pathfinder wheel + run: | + pathfinder_wheels=(wheels/cuda_pathfinder-*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + mkdir -p wheel-constraints + pathfinder_uri="file:///$(cygpath -am "${pathfinder_wheels[0]}")" + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" | tee wheel-constraints/cuda-bindings.txt + - name: Build cuda.bindings wheel run: | + export PIP_BUILD_CONSTRAINT="$(cygpath -w "$(pwd)/wheel-constraints/cuda-bindings.txt")" + export PIP_CONSTRAINT="${PIP_BUILD_CONSTRAINT}" cd cuda_bindings ../.venv/Scripts/pip wheel -v --no-deps . -w ../wheels/ - # Pin cuda-bindings to the wheel built above; PIP_PRE, which is what makes - # that .devN wheel visible, would otherwise let a PyPI pre-release win. + - name: Constrain cuda.core to the local cuda.bindings wheel + run: | + CUDA_MAJOR="${CUDA_VER%%.*}" + pathfinder_wheels=(wheels/cuda_pathfinder-*.whl) + bindings_wheels=(wheels/cuda_bindings-"${CUDA_MAJOR}".*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test "${#bindings_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + test -f "${bindings_wheels[0]}" + mkdir -p wheel-constraints + pathfinder_uri="file:///$(cygpath -am "${pathfinder_wheels[0]}")" + bindings_uri="file:///$(cygpath -am "${bindings_wheels[0]}")" + { + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" + printf 'cuda-bindings @ %s\n' "${bindings_uri}" + } | tee wheel-constraints/cuda-core.txt + - name: Build cuda.core wheel run: | - export PIP_FIND_LINKS="$(pwd)/wheels" - export PIP_PRE=1 - bindings_whl="$(ls ./wheels/cuda_bindings-*.whl | head -1)" - bindings_ver="$(basename "$bindings_whl" | cut -d- -f2)" - echo "cuda-bindings==${bindings_ver%%+*}" > "$GITHUB_WORKSPACE/constraints.txt" - cat "$GITHUB_WORKSPACE/constraints.txt" - export PIP_CONSTRAINT="$GITHUB_WORKSPACE/constraints.txt" + export PIP_BUILD_CONSTRAINT="$(cygpath -w "$(pwd)/wheel-constraints/cuda-core.txt")" + export PIP_CONSTRAINT="${PIP_BUILD_CONSTRAINT}" cd cuda_core ../.venv/Scripts/pip wheel -v --no-deps . -w ../wheels/ diff --git a/.github/workflows/test-sdist-linux.yml b/.github/workflows/test-sdist-linux.yml index 9d077912f3c..42262a8aa29 100644 --- a/.github/workflows/test-sdist-linux.yml +++ b/.github/workflows/test-sdist-linux.yml @@ -39,7 +39,7 @@ jobs: python-version: "3.12" - name: Install build tools - run: pip install build + run: python -m pip install "pip>=25.3" build # Pure Python packages -- no CTK needed. - name: Build cuda.pathfinder sdist and wheel-from-sdist @@ -52,6 +52,15 @@ jobs: python -m build --sdist cuda_python/ pip wheel --no-deps --wheel-dir cuda_python/dist cuda_python/dist/*.tar.gz + - name: Constrain builds to the local cuda.pathfinder wheel + run: | + pathfinder_wheels=(cuda_pathfinder/dist/cuda_pathfinder-*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + mkdir -p wheel-constraints + pathfinder_uri="file://$(realpath "${pathfinder_wheels[0]}")" + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" | tee wheel-constraints/cuda-bindings.txt + # Cython packages need CTK + sccache. # The env vars ACTIONS_CACHE_SERVICE_V2, ACTIONS_RESULTS_URL, and ACTIONS_RUNTIME_TOKEN # are exposed by this action. @@ -88,10 +97,28 @@ jobs: export CUDA_PYTHON_PARALLEL_LEVEL=$(nproc) export CC="sccache cc" export CXX="sccache c++" - export PIP_FIND_LINKS="$(pwd)/cuda_pathfinder/dist" + export PIP_BUILD_CONSTRAINT="$(pwd)/wheel-constraints/cuda-bindings.txt" + export PIP_CONSTRAINT="${PIP_BUILD_CONSTRAINT}" python -m build --sdist cuda_bindings/ pip wheel --no-deps --wheel-dir cuda_bindings/dist cuda_bindings/dist/*.tar.gz + - name: Constrain cuda.core to the local cuda.bindings wheel + run: | + CUDA_MAJOR="$(echo '${{ inputs.cuda-version }}' | cut -d. -f1)" + pathfinder_wheels=(cuda_pathfinder/dist/cuda_pathfinder-*.whl) + bindings_wheels=(cuda_bindings/dist/cuda_bindings-"${CUDA_MAJOR}".*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test "${#bindings_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + test -f "${bindings_wheels[0]}" + mkdir -p wheel-constraints + pathfinder_uri="file://$(realpath "${pathfinder_wheels[0]}")" + bindings_uri="file://$(realpath "${bindings_wheels[0]}")" + { + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" + printf 'cuda-bindings @ %s\n' "${bindings_uri}" + } | tee wheel-constraints/cuda-core.txt + # cuda_core sdist delegates to setuptools (no CTK needed), but # wheel-from-sdist needs CTK and cuda-bindings (dynamic build dep via # get_requires_for_build_wheel in build_hooks.py). @@ -101,7 +128,8 @@ jobs: export CUDA_CORE_BUILD_MAJOR="$(echo '${{ inputs.cuda-version }}' | cut -d. -f1)" export CC="sccache cc" export CXX="sccache c++" - export PIP_FIND_LINKS="$(pwd)/cuda_bindings/dist $(pwd)/cuda_pathfinder/dist" + export PIP_BUILD_CONSTRAINT="$(pwd)/wheel-constraints/cuda-core.txt" + export PIP_CONSTRAINT="${PIP_BUILD_CONSTRAINT}" python -m build --sdist cuda_core/ pip wheel --no-deps --wheel-dir cuda_core/dist cuda_core/dist/*.tar.gz diff --git a/.github/workflows/test-sdist-windows.yml b/.github/workflows/test-sdist-windows.yml index 043bacc1cad..eb4e25b5fc5 100644 --- a/.github/workflows/test-sdist-windows.yml +++ b/.github/workflows/test-sdist-windows.yml @@ -48,7 +48,7 @@ jobs: uses: step-security/msvc-dev-cmd@22c98154b708dbd743e6f27a933cf6ceba3305c4 # v1.13.1 - name: Install build tools - run: pip install build + run: python -m pip install "pip>=25.3" build # Pure Python packages -- no CTK needed. - name: Build cuda.pathfinder sdist and wheel-from-sdist @@ -61,6 +61,15 @@ jobs: python -m build --sdist cuda_python/ pip wheel --no-deps --wheel-dir cuda_python/dist cuda_python/dist/*.tar.gz + - name: Constrain builds to the local cuda.pathfinder wheel + run: | + pathfinder_wheels=(cuda_pathfinder/dist/cuda_pathfinder-*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + mkdir -p wheel-constraints + pathfinder_uri="file:///$(cygpath -am "${pathfinder_wheels[0]}")" + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" | tee wheel-constraints/cuda-bindings.txt + # Cython packages need CTK. No sccache on Windows (this is a correctness # smoke test, not a production build; see build-wheel.yml which also # limits sccache to Linux). @@ -73,17 +82,33 @@ jobs: # cuda_bindings/setup.py parses CUDA headers at import time, so CUDA_PATH # (set by fetch_ctk) must be available for both sdist and wheel builds. - # PIP_FIND_LINKS is passed as a native Windows path via cygpath because - # pip on Windows treats space-separated entries as separators and is - # picky about mixed path styles (see build-wheel.yml for the same - # convention). + # Constraint paths are passed as native Windows paths because the pip + # subprocesses run outside Git Bash. - name: Build cuda.bindings sdist and wheel-from-sdist run: | export CUDA_PYTHON_PARALLEL_LEVEL=$(nproc) - export PIP_FIND_LINKS="$(cygpath -w "$(pwd)/cuda_pathfinder/dist")" + export PIP_BUILD_CONSTRAINT="$(cygpath -w "$(pwd)/wheel-constraints/cuda-bindings.txt")" + export PIP_CONSTRAINT="${PIP_BUILD_CONSTRAINT}" python -m build --sdist cuda_bindings/ pip wheel --no-deps --wheel-dir cuda_bindings/dist cuda_bindings/dist/*.tar.gz + - name: Constrain cuda.core to the local cuda.bindings wheel + run: | + CUDA_MAJOR="$(echo '${{ inputs.cuda-version }}' | cut -d. -f1)" + pathfinder_wheels=(cuda_pathfinder/dist/cuda_pathfinder-*.whl) + bindings_wheels=(cuda_bindings/dist/cuda_bindings-"${CUDA_MAJOR}".*.whl) + test "${#pathfinder_wheels[@]}" -eq 1 + test "${#bindings_wheels[@]}" -eq 1 + test -f "${pathfinder_wheels[0]}" + test -f "${bindings_wheels[0]}" + mkdir -p wheel-constraints + pathfinder_uri="file:///$(cygpath -am "${pathfinder_wheels[0]}")" + bindings_uri="file:///$(cygpath -am "${bindings_wheels[0]}")" + { + printf 'cuda-pathfinder @ %s\n' "${pathfinder_uri}" + printf 'cuda-bindings @ %s\n' "${bindings_uri}" + } | tee wheel-constraints/cuda-core.txt + # cuda_core sdist delegates to setuptools (no CTK needed), but # wheel-from-sdist needs CTK and cuda-bindings (dynamic build dep via # get_requires_for_build_wheel in build_hooks.py). @@ -91,6 +116,7 @@ jobs: run: | export CUDA_PYTHON_PARALLEL_LEVEL=$(nproc) export CUDA_CORE_BUILD_MAJOR="$(echo '${{ inputs.cuda-version }}' | cut -d. -f1)" - export PIP_FIND_LINKS="$(cygpath -w "$(pwd)/cuda_bindings/dist") $(cygpath -w "$(pwd)/cuda_pathfinder/dist")" + export PIP_BUILD_CONSTRAINT="$(cygpath -w "$(pwd)/wheel-constraints/cuda-core.txt")" + export PIP_CONSTRAINT="${PIP_BUILD_CONSTRAINT}" python -m build --sdist cuda_core/ pip wheel --no-deps --wheel-dir cuda_core/dist cuda_core/dist/*.tar.gz From 3bd069abe39536b4b6bf20220043361f5a520d28 Mon Sep 17 00:00:00 2001 From: Rui Luo Date: Sat, 8 Aug 2026 12:17:02 -0700 Subject: [PATCH 47/50] fix(pathfinder): place Windows arm64 cudart test fixtures under bin/arm64 (#2528) --- cuda_pathfinder/tests/test_ctk_root_discovery.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/cuda_pathfinder/tests/test_ctk_root_discovery.py b/cuda_pathfinder/tests/test_ctk_root_discovery.py index f232afe7719..731d38fdc0a 100644 --- a/cuda_pathfinder/tests/test_ctk_root_discovery.py +++ b/cuda_pathfinder/tests/test_ctk_root_discovery.py @@ -81,7 +81,11 @@ def _create_nvvm_in_ctk(ctk_root): def _create_cudart_in_ctk(ctk_root): """Create a fake cudart lib in the platform-appropriate CTK subdirectory.""" if IS_WINDOWS: - lib_dir = ctk_root / "bin" + # Native ARM64 uses bin/arm64 only. + if windows_python_arch() == "arm64": + lib_dir = ctk_root / "bin" / "arm64" + else: + lib_dir = ctk_root / "bin" lib_dir.mkdir(parents=True) lib_file = lib_dir / "cudart64_12.dll" else: From 4b13910beb613fe4f7a10be4af194b954670e5c2 Mon Sep 17 00:00:00 2001 From: Ralf Juengling Date: Sun, 9 Aug 2026 19:11:24 -0700 Subject: [PATCH 48/50] fix(pixi): restore conda test deps and relock after #2384 (#2532) #2384 inserted a pypi-dependencies header mid-table, moving conda test deps to PyPI without updating lockfiles. Fresh CI installs then dropped the local cuda-bindings/cuda-core source packages, causing ModuleNotFoundError. --- cuda_bindings/pixi.lock | 2639 +++++++++++++++++++++++++-------------- cuda_bindings/pixi.toml | 6 +- cuda_core/pixi.lock | 2506 ++++++++++++++++++++++++++++++++----- cuda_core/pixi.toml | 6 +- 4 files changed, 3845 insertions(+), 1312 deletions(-) diff --git a/cuda_bindings/pixi.lock b/cuda_bindings/pixi.lock index 1cab16dd77a..81e0045322d 100644 --- a/cuda_bindings/pixi.lock +++ b/cuda_bindings/pixi.lock @@ -20,6 +20,8 @@ environments: cu12: channels: - url: https://conda.anaconda.org/conda-forge/ + indexes: + - https://pypi.org/simple packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda @@ -77,15 +79,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.2-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.2-h73754d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.1.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.4-h6548e54_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.2-default_hafda6a7_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwy-1.3.0-h4c17acf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda @@ -120,8 +122,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.52.0-hf4e2dac_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.1.0-hdf11a46_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.10-hd0affe5_4.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.10-hd0affe5_4.conda @@ -220,8 +222,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[04818863] @ . - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder + - conda_source: cuda-bindings[595e6447] @ . + - conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -275,15 +278,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libflac-1.5.0-he9c94f4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.2-h8af1aa0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.2-hdae7a39_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-16.1.0-he9431aa_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.4-hf53f6bf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.2-default_ha470c98_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwy-1.3.0-h81d0cf9_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda @@ -316,8 +319,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsndfile-1.2.2-h30591a0_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.52.0-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-16.1.0-hdbbeba8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.10-hf9559e3_4.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.10-hf9559e3_4.conda @@ -412,8 +415,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[748b2e6f] @ . - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder + - conda_source: cuda-bindings[cb9a5e74] @ . + - conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda @@ -551,11 +555,14 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[341f49d8] @ . - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder + - conda_source: cuda-bindings[38bd5059] @ . + - conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers cu13: channels: - url: https://conda.anaconda.org/conda-forge/ + indexes: + - https://pypi.org/simple packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 @@ -611,15 +618,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.1-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.1-h73754d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_16.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_16.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.1.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.3-h6548e54_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_16.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.1-default_hafda6a7_1003.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.2-hb03c661_0.conda @@ -652,8 +659,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.51.1-hf4e2dac_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_16.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_16.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.1.0-hdf11a46_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda @@ -750,8 +757,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[5987685b] @ . - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder + - conda_source: cuda-bindings[33376fba] @ . + - conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.1-he30d5cf_0.conda @@ -801,15 +809,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libflac-1.5.0-he9c94f4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.1-h8af1aa0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.1-hdae7a39_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_16.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_16.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-16.1.0-he9431aa_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.3-hf53f6bf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_16.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.1-default_ha470c98_1003.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.2-he30d5cf_0.conda @@ -840,8 +848,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsndfile-1.2.2-h30591a0_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.51.1-h10b116e_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_16.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_16.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-16.1.0-hdbbeba8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda @@ -933,8 +941,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[d33f8c8b] @ . - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder + - conda_source: cuda-bindings[9909e402] @ . + - conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.1.4-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda @@ -1066,11 +1075,14 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[8de8dc46] @ . - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder + - conda_source: cuda-bindings[943c652a] @ . + - conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers default: channels: - url: https://conda.anaconda.org/conda-forge/ + indexes: + - https://pypi.org/simple packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 @@ -1081,14 +1093,14 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.4-h3394656_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-15.2.0-h53410ce_16.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-13.3.33-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-13.3.73-h69a702a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.73-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.73-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.9.86-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-12.9.86-h69a702a_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.9.86-h4bc722e_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.9.86-h4bc722e_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.9.79-h7938cbb_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda @@ -1117,7 +1129,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-5_h4a7cf45_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-hd0affe5_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-5_h0358290_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.18.1.6-h053a66a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.14.1.1-hbc026e6_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.125-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda @@ -1126,15 +1138,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.1-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.1-h73754d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_15.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_15.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.1.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.3-h6548e54_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_15.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.1-default_hafda6a7_1003.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.2-hb03c661_0.conda @@ -1142,8 +1154,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-13.3.29-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-12.9.82-hecca717_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-12.9.86-hecca717_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libogg-1.3.5-hd0c01bc_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_4.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2025.2.0-hb617929_1.conda @@ -1167,8 +1179,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.51.1-h0c1763c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_15.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_15.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.1.0-hdf11a46_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda @@ -1229,13 +1241,13 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.11.12-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.73-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.9.27-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -1265,8 +1277,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[5987685b] @ . - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder + - conda_source: cuda-bindings[595e6447] @ . + - conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.1-he30d5cf_0.conda @@ -1274,14 +1287,14 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45-default_h5f4c503_104.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cairo-1.18.4-h83712da_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-13.3.33-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-13.3.73-he9431aa_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.73-h7b14b0b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-12.9.86-h8f3c8d4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-12.9.86-he9431aa_106.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-12.9.86-h7b14b0b_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-12.9.86-h7b14b0b_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-12.9.79-h16bee8c_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda @@ -1307,7 +1320,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-5_haddc8a3_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-5_hd72aa62_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.14.1.1-had8bf56_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdeflate-1.25-h1af38f5_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdrm-2.4.125-he30d5cf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libegl-1.7.0-hd24410f_2.conda @@ -1316,15 +1329,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libflac-1.5.0-he9c94f4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.1-h8af1aa0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.1-hdae7a39_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_15.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_15.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-16.1.0-he9431aa_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.3-hf53f6bf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_15.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.1-default_ha470c98_1003.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.2-he30d5cf_0.conda @@ -1332,8 +1345,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.1-h86ecc28_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-h86ecc28_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-12.9.82-h8f3c8d4_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-12.9.86-h8f3c8d4_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libogg-1.3.5-h86ecc28_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.30-pthreads_h9d3fd7e_4.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-2025.2.0-hcd21e76_1.conda @@ -1355,8 +1368,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_16.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsndfile-1.2.2-h30591a0_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.51.1-h022381a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_15.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_15.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-16.1.0-hdbbeba8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda @@ -1413,13 +1426,13 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.11.12-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.73-h579c4fd_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-12.9.27-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -1448,8 +1461,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[d33f8c8b] @ . - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder + - conda_source: cuda-bindings[cb9a5e74] @ . + - conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.11.12-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda @@ -1581,8 +1595,9 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[341f49d8] @ . - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder + - conda_source: cuda-bindings[38bd5059] @ . + - conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers docs: channels: - url: https://conda.anaconda.org/conda-forge/ @@ -2112,6 +2127,7 @@ packages: sha256: fe51de6107f9edc7aa4f786a70f4a883943bc9d39b3bb7307c04c41410990726 md5: d7c89558ba9fa0495403155b64376d81 license: None + purls: [] size: 2562 timestamp: 1578324546067 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda @@ -2142,6 +2158,7 @@ packages: - openmp_impl 9999 license: BSD-3-Clause license_family: BSD + purls: [] size: 23621 timestamp: 1650670423406 - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.15.1-hb03c661_0.conda @@ -2152,6 +2169,7 @@ packages: - libgcc >=14 license: LGPL-2.1-or-later license_family: GPL + purls: [] size: 585491 timestamp: 1766155792553 - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.15.3-hb03c661_0.conda @@ -2162,6 +2180,7 @@ packages: - libgcc >=14 license: LGPL-2.1-or-later license_family: GPL + purls: [] size: 584660 timestamp: 1768327524772 - conda: https://conda.anaconda.org/conda-forge/linux-64/aom-3.9.1-hac33072_0.conda @@ -2172,6 +2191,7 @@ packages: - libstdcxx-ng >=12 license: BSD-2-Clause license_family: BSD + purls: [] size: 2706396 timestamp: 1718551242397 - conda: https://conda.anaconda.org/conda-forge/linux-64/attr-2.5.2-h39aace5_0.conda @@ -2182,6 +2202,7 @@ packages: - libgcc >=13 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 68072 timestamp: 1756738968573 - conda: https://conda.anaconda.org/conda-forge/linux-64/backports.zstd-1.3.0-py312h90b7ffd_0.conda @@ -2207,6 +2228,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 3747046 timestamp: 1764007847963 - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45-default_hfdba357_105.conda @@ -2218,6 +2240,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 3719982 timestamp: 1766513109980 - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_101.conda @@ -2229,6 +2252,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 3744895 timestamp: 1770267152681 - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda @@ -2270,6 +2294,19 @@ packages: - pkg:pypi/brotli?source=hash-mapping size: 368300 timestamp: 1764017300621 +- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + sha256: 1a0d382c515ebf55f8ee1f38c8b81bc95af5c2acc42ad53b66bc5df932032f96 + md5: e675fabcf81499adc7edf58124fb1e01 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: bzip2-1.0.6 + license_family: BSD + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 257808 + timestamp: 1785906269155 - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda sha256: c30daba32ddebbb7ded490f0e371eae90f51e72db620554089103b4a6934b0d5 md5: 51a19bba1b8ebfb60df25cde030b7ebc @@ -2278,6 +2315,7 @@ packages: - libgcc >=14 license: bzip2-1.0.6 license_family: BSD + purls: [] size: 260341 timestamp: 1757437258798 - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda @@ -2317,6 +2355,7 @@ packages: - xorg-libxext >=1.3.6,<2.0a0 - xorg-libxrender >=0.9.12,<0.10.0a0 license: LGPL-2.1-only or MPL-1.1 + purls: [] size: 978114 timestamp: 1741554591855 - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.4-he90730b_1.conda @@ -2343,6 +2382,7 @@ packages: - xorg-libxext >=1.3.6,<2.0a0 - xorg-libxrender >=0.9.12,<0.10.0a0 license: LGPL-2.1-only or MPL-1.1 + purls: [] size: 989514 timestamp: 1766415934926 - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-15.2.0-h53410ce_16.conda @@ -2352,6 +2392,7 @@ packages: - gcc_impl_linux-64 >=15.2.0,<15.2.1.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 31290 timestamp: 1765257044086 - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-bindings-13.2.0-py312hf79963d_0.conda @@ -2387,6 +2428,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23242 timestamp: 1749218416505 @@ -2400,6 +2442,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24659 timestamp: 1779898425780 @@ -2415,6 +2458,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -2432,6 +2476,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=13.3.29,<14.0a0 @@ -2447,6 +2492,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23283 timestamp: 1749218442382 @@ -2460,6 +2506,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24626 timestamp: 1779898435744 @@ -2472,6 +2519,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 67168282 timestamp: 1760723629347 @@ -2530,6 +2578,7 @@ packages: - cuda-nvvm-impl 12.9.86.* - cuda-nvvm-tools 12.9.86.* license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 25475 timestamp: 1771619493286 @@ -2541,6 +2590,7 @@ packages: - cuda-nvvm-impl 13.3.33.* - cuda-nvvm-tools 13.3.33.* license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 25697 timestamp: 1779909800589 - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-13.3.73-h69a702a_0.conda @@ -2562,6 +2612,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 21425520 timestamp: 1753975283188 @@ -2595,6 +2646,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24246736 timestamp: 1753975332907 @@ -2606,6 +2658,7 @@ packages: - cuda-version >=13.3,<13.4.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 29720382 timestamp: 1779905121216 - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.73-h4bc722e_0.conda @@ -2626,6 +2679,7 @@ packages: - cuda-cudart-dev - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23668 timestamp: 1761098836058 @@ -2636,6 +2690,7 @@ packages: - cuda-cudart-dev - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 25007 timestamp: 1779913616712 @@ -2650,6 +2705,8 @@ packages: - python_abi 3.14.* *_cp314 license: Apache-2.0 license_family: APACHE + purls: + - pkg:pypi/cython?source=hash-mapping run_exports: {} size: 3819412 timestamp: 1782821647528 @@ -2676,6 +2733,7 @@ packages: - libgcc-ng >=12 license: BSD-2-Clause license_family: BSD + purls: [] size: 760229 timestamp: 1685695754230 - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda @@ -2689,6 +2747,7 @@ packages: - libglib >=2.86.2,<3.0a0 - libexpat >=2.7.3,<3.0a0 license: AFL-2.1 OR GPL-2.0-or-later + purls: [] size: 447649 timestamp: 1764536047944 - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.20-py312h8285ef7_0.conda @@ -2765,6 +2824,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 12482468 timestamp: 1765653517558 - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-8.0.1-gpl_hcddb375_914.conda @@ -2828,6 +2888,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 12485347 timestamp: 1773008832077 - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.15.0-h7e30c49_1.conda @@ -2842,6 +2903,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 265599 timestamp: 1730283881107 - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.17.1-h27c8c51_0.conda @@ -2857,6 +2919,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 270705 timestamp: 1771382710863 - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.1-ha770c72_0.conda @@ -2866,6 +2929,7 @@ packages: - libfreetype 2.14.1 ha770c72_0 - libfreetype6 2.14.1 h73754d4_0 license: GPL-2.0-only OR FTL + purls: [] size: 173114 timestamp: 1757945422243 - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.2-ha770c72_0.conda @@ -2875,6 +2939,7 @@ packages: - libfreetype 2.14.2 ha770c72_0 - libfreetype6 2.14.2 h73754d4_0 license: GPL-2.0-only OR FTL + purls: [] size: 174292 timestamp: 1772757205296 - conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.16-hb03c661_0.conda @@ -2884,6 +2949,7 @@ packages: - __glibc >=2.17,<3.0.a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 61244 timestamp: 1757438574066 - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-15.2.0-h0dff253_16.conda @@ -2894,6 +2960,7 @@ packages: - gcc_impl_linux-64 15.2.0 hc5723f1_16 license: BSD-3-Clause license_family: BSD + purls: [] size: 28938 timestamp: 1765257209407 - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-15.2.0-h6f77f03_18.conda @@ -2905,6 +2972,7 @@ packages: - gcc_no_conda_specs license: BSD-3-Clause license_family: BSD + purls: [] size: 29453 timestamp: 1771378662937 - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-15.2.0-hc5723f1_16.conda @@ -2921,25 +2989,9 @@ packages: - sysroot_linux-64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 80309755 timestamp: 1765256937267 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-15.2.0-he0086c7_19.conda - sha256: a48400ec4b73369c1c59babe4ad35821b63a88bba0ec40a80cea5f8c53a26b83 - md5: e3be72048d3c4a78b8e27ec48ba06252 - depends: - - binutils_impl_linux-64 >=2.45 - - libgcc >=15.2.0 - - libgcc-devel_linux-64 15.2.0 hcc6f6b0_119 - - libgomp >=15.2.0 - - libsanitizer 15.2.0 h90f66d4_19 - - libstdcxx >=15.2.0 - - libstdcxx-devel_linux-64 15.2.0 hd446a21_119 - - sysroot_linux-64 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - run_exports: {} - size: 81180457 - timestamp: 1778269124617 - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-15.2.0-he420e7e_18.conda sha256: a088cfd3ae6fa83815faa8703bc9d21cc915f17bd1b51aac9c16ddf678da21e4 md5: cf56b6d74f580b91fd527e10d9a2e324 @@ -2954,22 +3006,40 @@ packages: - sysroot_linux-64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 81814135 timestamp: 1771378369317 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-15.2.0-h7be306e_27.conda - sha256: b24b13d467898a9b9a17a868a2686412a98f8935dc7cc51547dd90645d4e8436 - md5: 28bc49875f9c38e2401696b3e48d0798 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-16.1.0-h5fcb69b_1.conda + sha256: 00c87015522248adb5565a1b8f977cfe927831dd7ef0cb0a5d13f896844af719 + md5: 419982d8913246db404319048e062d3e + depends: + - binutils_impl_linux-64 >=2.46.1 + - libgcc >=16.1.0 + - libgcc-devel_linux-64 16.1.0 h59071f9_101 + - libgomp >=16.1.0 + - libsanitizer 16.1.0 hf2715c6_1 + - libstdcxx >=16.1.0 + - libstdcxx-devel_linux-64 16.1.0 h41cdd0d_101 + - sysroot_linux-64 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 85161422 + timestamp: 1785375529345 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-16.1.0-h5fd2508_0.conda + sha256: 22d2b2c0386fda70971c87afd4926cb20ba1a247421f5be617c43512570fa4f7 + md5: 15b9577e4be98443deb42e88e9c44656 depends: - - gcc_impl_linux-64 15.2.0.* + - gcc_impl_linux-64 16.1.0.* - binutils_linux-64 - sysroot_linux-64 license: BSD-3-Clause license_family: BSD run_exports: strong: - - libgcc >=15 - size: 29330 - timestamp: 1781279944230 + - libgcc >=16 + size: 29720 + timestamp: 1785386616206 - conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.44.4-h2b0a6b4_0.conda sha256: f47222f58839bcc77c15f11a8814c1d8cb8080c5ca6ba83398a12b640fd3c85c md5: c379d67c686fb83475c1a6ed41cc41ff @@ -2983,6 +3053,7 @@ packages: - libtiff >=4.7.1,<4.8.0a0 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 572093 timestamp: 1761082340749 - conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.44.5-h2b0a6b4_1.conda @@ -2998,6 +3069,7 @@ packages: - libtiff >=4.7.1,<4.8.0a0 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 575109 timestamp: 1771530561157 - conda: https://conda.anaconda.org/conda-forge/linux-64/glslang-16.1.0-hfd11570_0.conda @@ -3010,6 +3082,7 @@ packages: - spirv-tools >=2025,<2026.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1312583 timestamp: 1764720535916 - conda: https://conda.anaconda.org/conda-forge/linux-64/glslang-16.2.0-h96af755_1.conda @@ -3022,6 +3095,7 @@ packages: - spirv-tools >=2026,<2027.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1353008 timestamp: 1770195199411 - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda @@ -3031,6 +3105,7 @@ packages: - libgcc-ng >=12 - libstdcxx-ng >=12 license: GPL-2.0-or-later OR LGPL-3.0-or-later + purls: [] size: 460055 timestamp: 1718980856608 - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.14-hecca717_2.conda @@ -3042,6 +3117,7 @@ packages: - libstdcxx >=14 license: LGPL-2.0-or-later license_family: LGPL + purls: [] size: 99596 timestamp: 1755102025473 - conda: https://conda.anaconda.org/conda-forge/linux-64/greenlet-3.3.2-py312h8285ef7_0.conda @@ -3067,6 +3143,7 @@ packages: - gxx_impl_linux-64 15.2.0 hda75c37_16 license: BSD-3-Clause license_family: BSD + purls: [] size: 28467 timestamp: 1765257244273 - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-15.2.0-h76987e4_18.conda @@ -3077,6 +3154,7 @@ packages: - gxx_impl_linux-64 15.2.0 hda75c37_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 28723 timestamp: 1771378698305 - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-15.2.0-hda75c37_16.conda @@ -3089,6 +3167,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 16357678 timestamp: 1765257161133 - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-15.2.0-hda75c37_18.conda @@ -3101,37 +3180,38 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 15587873 timestamp: 1771378609722 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-15.2.0-hda75c37_19.conda - sha256: 3f5288346b9fe233352443b3c2e31f1fde845e39d3e96475fc05ec2e782af158 - md5: 9d41f3899b512199af0a4bb939b83e21 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-16.1.0-he33a5f8_1.conda + sha256: 4b7e7a082fab18a58409b05c2611b8edb4aeb06ee07be380a73da5de911da2ba + md5: aaeab97072d79e7945182dc7d4e1a035 depends: - - gcc_impl_linux-64 15.2.0 he0086c7_19 - - libstdcxx-devel_linux-64 15.2.0 hd446a21_119 + - gcc_impl_linux-64 16.1.0 h5fcb69b_1 + - libstdcxx-devel_linux-64 16.1.0 h41cdd0d_101 - sysroot_linux-64 - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL run_exports: {} - size: 16356816 - timestamp: 1778269332159 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-15.2.0-hcb00b6d_27.conda - sha256: f78da7a8b49943a6ce48372a5bc85ab741ac86666f1040e8876545065ec1096e - md5: 5e194579a5f72c70102f342aa362f5f9 - depends: - - gxx_impl_linux-64 15.2.0.* - - gcc_linux-64 ==15.2.0 h7be306e_27 + size: 16633585 + timestamp: 1785375706410 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-16.1.0-h5525346_0.conda + sha256: c8c0b721dadcc8d48d2a5a9ee56add4b46ce5427adbf6ff685e0f75fabd52cbd + md5: 4521cfa739a42179511b351566374c6e + depends: + - gxx_impl_linux-64 16.1.0.* + - gcc_linux-64 ==16.1.0 h5fd2508_0 - binutils_linux-64 - sysroot_linux-64 license: BSD-3-Clause license_family: BSD run_exports: strong: - - libstdcxx >=15 - - libgcc >=15 - size: 27848 - timestamp: 1781279944230 + - libstdcxx >=16 + - libgcc >=16 + size: 28116 + timestamp: 1785386616206 - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-12.2.0-h15599e2_0.conda sha256: 6bd8b22beb7d40562b2889dc68232c589ff0d11a5ad3addd41a8570d11f039d9 md5: b8690f53007e9b5ee2c2178dd4ac778c @@ -3149,6 +3229,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 2411408 timestamp: 1762372726141 - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-12.3.0-h6083320_0.conda @@ -3168,6 +3249,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 2062122 timestamp: 1766937132307 - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-13.1.0-h6083320_0.conda @@ -3187,6 +3269,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 2615630 timestamp: 1773217509651 - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda @@ -3198,6 +3281,7 @@ packages: - libstdcxx-ng >=12 license: MIT license_family: MIT + purls: [] size: 12129203 timestamp: 1720853576813 - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.1-h33c6efd_0.conda @@ -3209,6 +3293,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 12722920 timestamp: 1766299101259 - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.2-h33c6efd_0.conda @@ -3220,6 +3305,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 12728445 timestamp: 1767969922681 - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda @@ -3234,6 +3320,20 @@ packages: purls: [] size: 12723451 timestamp: 1773822285671 +- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda + sha256: d7c260b7e1cf22ce04d6ba8a86eabf4e6c50bc96a5c27fe2ecb32298af3e88eb + md5: 4ef4b977bb216a3001a3334696a80850 + depends: + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + run_exports: + weak: + - icu >=78.3,<79.0a0 + size: 14455340 + timestamp: 1784916378180 - conda: https://conda.anaconda.org/conda-forge/linux-64/intel-gmmlib-22.9.0-hb700be7_0.conda sha256: edad668db79c6c4899d46e1cd4a331f5d008f9ed8f7d2e39e1dfe1a2d81acec0 md5: 26311c5112b5c713f472bdfbb5ec5aa3 @@ -3243,6 +3343,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 1009795 timestamp: 1765886047465 - conda: https://conda.anaconda.org/conda-forge/linux-64/intel-media-driver-25.3.4-hecca717_0.conda @@ -3256,6 +3357,7 @@ packages: - libva >=2.22.0,<3.0a0 license: MIT license_family: MIT + purls: [] size: 8424610 timestamp: 1757591682198 - conda: https://conda.anaconda.org/conda-forge/linux-64/intel-media-driver-26.1.4-hecca717_0.conda @@ -3269,6 +3371,7 @@ packages: - libva >=2.23.0,<3.0a0 license: MIT license_family: MIT + purls: [] size: 8783533 timestamp: 1773230300873 - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda @@ -3304,6 +3407,7 @@ packages: - libgcc-ng >=12 license: LGPL-2.0-only license_family: LGPL + purls: [] size: 508258 timestamp: 1664996250081 - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45-default_hbd61a6d_104.conda @@ -3316,6 +3420,7 @@ packages: - binutils_impl_linux-64 2.45 license: GPL-3.0-only license_family: GPL + purls: [] size: 725545 timestamp: 1764007826689 - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45-default_hbd61a6d_105.conda @@ -3328,6 +3433,7 @@ packages: - binutils_impl_linux-64 2.45 license: GPL-3.0-only license_family: GPL + purls: [] size: 730831 timestamp: 1766513089214 - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_101.conda @@ -3340,6 +3446,7 @@ packages: - binutils_impl_linux-64 2.45.1 license: GPL-3.0-only license_family: GPL + purls: [] size: 725507 timestamp: 1770267139900 - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda @@ -3377,6 +3484,7 @@ packages: - libstdcxx >=13 license: Apache-2.0 license_family: Apache + purls: [] size: 264243 timestamp: 1745264221534 - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda @@ -3388,6 +3496,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: Apache + purls: [] size: 261513 timestamp: 1773113328888 - conda: https://conda.anaconda.org/conda-forge/linux-64/level-zero-1.26.2-hb700be7_0.conda @@ -3399,6 +3508,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 667315 timestamp: 1765910088541 - conda: https://conda.anaconda.org/conda-forge/linux-64/level-zero-1.26.3-hb700be7_0.conda @@ -3410,6 +3520,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 667437 timestamp: 1766226025812 - conda: https://conda.anaconda.org/conda-forge/linux-64/level-zero-1.28.2-hb700be7_0.conda @@ -3421,6 +3532,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 858387 timestamp: 1772045965844 - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20250512.1-cxx17_hba17884_0.conda @@ -3435,6 +3547,7 @@ packages: - abseil-cpp =20250512.1 license: Apache-2.0 license_family: Apache + purls: [] size: 1310612 timestamp: 1750194198254 - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20260107.1-cxx17_h7b12aa8_0.conda @@ -3449,6 +3562,7 @@ packages: - abseil-cpp =20260107.1 license: Apache-2.0 license_family: Apache + purls: [] size: 1384817 timestamp: 1770863194876 - conda: https://conda.anaconda.org/conda-forge/linux-64/libass-0.17.4-h96ad9f0_0.conda @@ -3466,6 +3580,7 @@ packages: - fonts-conda-ecosystem - harfbuzz >=11.0.1 license: ISC + purls: [] size: 152179 timestamp: 1749328931930 - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-5_h4a7cf45_openblas.conda @@ -3483,6 +3598,7 @@ packages: - liblapacke 3.11.0 5*_openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18213 timestamp: 1765818813880 - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-6_h4a7cf45_openblas.conda @@ -3511,6 +3627,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 79965 timestamp: 1764017188531 - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda @@ -3522,6 +3639,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 34632 timestamp: 1764017199083 - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda @@ -3533,6 +3651,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 298378 timestamp: 1764017210931 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.77-h3ff7636_0.conda @@ -3544,6 +3663,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 121429 timestamp: 1762349484074 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.77-hd0affe5_1.conda @@ -3557,6 +3677,19 @@ packages: purls: [] size: 124432 timestamp: 1774333989027 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-h084b8d7_1.conda + sha256: 8cb25174d6b6fac95d31e86cfe41faffc8ee9dacbf2bfd22e6c23377e8f338c1 + md5: 5db514adf5f843126ff846d1510f22a4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libcap >=2.78,<2.79.0a0 + size: 124306 + timestamp: 1786025967663 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-hd0affe5_0.conda sha256: cc8c9fc6ddf0fbd3d1275b558ae9abad6cda23bced268732e2da21a87bb358cd md5: f9f17eab7f3df1c6fd4b1a548a2f683a @@ -3565,6 +3698,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] run_exports: weak: - libcap >=2.78,<2.79.0a0 @@ -3582,6 +3716,7 @@ packages: - liblapack 3.11.0 5*_openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18194 timestamp: 1765818837135 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-6_h0358290_openblas.conda @@ -3609,6 +3744,7 @@ packages: - libstdcxx >=14 - rdma-core >=59.0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 969845 timestamp: 1761098818759 @@ -3635,6 +3771,7 @@ packages: - libstdcxx >=14 - rdma-core >=63.0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1117538 timestamp: 1782772352403 @@ -3680,6 +3817,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 73490 timestamp: 1761979956660 - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.125-hb03c661_1.conda @@ -3691,6 +3829,7 @@ packages: - libpciaccess >=0.18,<0.19.0a0 license: MIT license_family: MIT + purls: [] size: 310785 timestamp: 1757212153962 - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda @@ -3713,6 +3852,7 @@ packages: - __glibc >=2.17,<3.0.a0 - libglvnd 1.7.0 ha4b6fd6_2 license: LicenseRef-libglvnd + purls: [] size: 44840 timestamp: 1731330973553 - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.3-hecca717_0.conda @@ -3725,6 +3865,7 @@ packages: - expat 2.7.3.* license: MIT license_family: MIT + purls: [] size: 76643 timestamp: 1763549731408 - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.4-hecca717_0.conda @@ -3737,6 +3878,7 @@ packages: - expat 2.7.4.* license: MIT license_family: MIT + purls: [] size: 76798 timestamp: 1771259418166 - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.5-hecca717_0.conda @@ -3787,6 +3929,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 57821 timestamp: 1760295480630 - conda: https://conda.anaconda.org/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda @@ -3800,6 +3943,7 @@ packages: - libstdcxx >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 424563 timestamp: 1764526740626 - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.1-ha770c72_0.conda @@ -3808,6 +3952,7 @@ packages: depends: - libfreetype6 >=2.14.1 license: GPL-2.0-only OR FTL + purls: [] size: 7664 timestamp: 1757945417134 - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.2-ha770c72_0.conda @@ -3816,6 +3961,7 @@ packages: depends: - libfreetype6 >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 8035 timestamp: 1772757210108 - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.1-h73754d4_0.conda @@ -3829,6 +3975,7 @@ packages: constrains: - freetype >=2.14.1 license: GPL-2.0-only OR FTL + purls: [] size: 386739 timestamp: 1757945416744 - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.2-h73754d4_0.conda @@ -3842,33 +3989,9 @@ packages: constrains: - freetype >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 386316 timestamp: 1772757193822 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_15.conda - sha256: 37f2edde2f8281672987c63f13c85a57d04d889dc929ce38204426d5eb2059cc - md5: a5d86b0496174a412d531eac03af9174 - depends: - - __glibc >=2.17,<3.0.a0 - - _openmp_mutex >=4.5 - constrains: - - libgomp 15.2.0 he0feb66_15 - - libgcc-ng ==15.2.0=*_15 - license: GPL-3.0-only WITH GCC-exception-3.1 - size: 1041379 - timestamp: 1764836112865 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_16.conda - sha256: 6eed58051c2e12b804d53ceff5994a350c61baf117ec83f5f10c953a3f311451 - md5: 6d0363467e6ed84f11435eb309f2ff06 - depends: - - __glibc >=2.17,<3.0.a0 - - _openmp_mutex >=4.5 - constrains: - - libgcc-ng ==15.2.0=*_16 - - libgomp 15.2.0 he0feb66_16 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 1042798 - timestamp: 1765256792743 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_18.conda sha256: faf7d2017b4d718951e3a59d081eb09759152f93038479b768e3d612688f83f5 md5: 0aa00f03f9e39fb9876085dee11a85d4 @@ -3883,38 +4006,21 @@ packages: purls: [] size: 1041788 timestamp: 1771378212382 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - sha256: 8e0a3b5e41272e5678499b5dfc4cddb673f9e935de01eb0767ce857001229f46 - md5: 57736f29cc2b0ec0b6c2952d3f101b6a +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + sha256: d5cb8475131c31680f8fd30512c418f373064e272e452063276a8fb14c9fa42f + md5: 5a7d954665c707c93311657cd779c705 depends: - __glibc >=2.17,<3.0.a0 - _openmp_mutex >=4.5 constrains: - - libgcc-ng ==15.2.0=*_19 - - libgomp 15.2.0 he0feb66_19 + - libgomp 16.1.0 he0feb66_1 + - libgcc-ng ==16.1.0=*_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] run_exports: {} - size: 1041084 - timestamp: 1778269013026 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_15.conda - sha256: 497d8cdba0da8fa154613d1c15f585674cadc194964ed1b4fe7c2809938dc41f - md5: 7b742943660c5173bb6a5c823021c9a0 - depends: - - libgcc 15.2.0 he0feb66_15 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 26834 - timestamp: 1764836127111 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_16.conda - sha256: 5f07f9317f596a201cc6e095e5fc92621afca64829785e483738d935f8cab361 - md5: 5a68259fac2da8f2ee6f7bfe49c9eb8b - depends: - - libgcc 15.2.0 he0feb66_16 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 27256 - timestamp: 1765256804124 + size: 1057877 + timestamp: 1785375436766 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_18.conda sha256: e318a711400f536c81123e753d4c797a821021fb38970cebfb3f454126016893 md5: d5e96b1ed75ca01906b3d2469b4ce493 @@ -3925,6 +4031,19 @@ packages: purls: [] size: 27526 timestamp: 1771378224552 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.1.0-h69a702a_1.conda + sha256: 225275c562337a1cd61705da0ee4235dde7bba7504de1c34b74c894adb2b0eee + md5: 7ed870c014a6f23c7dfafda53d2763a9 + depends: + - libgcc 16.1.0 ha9f2e26_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libgcc + size: 28210 + timestamp: 1785375440733 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_16.conda sha256: 8a7b01e1ee1c462ad243524d76099e7174ebdd94ff045fe3e9b1e58db196463b md5: 40d9b534410403c821ff64f00d0adc22 @@ -3934,6 +4053,7 @@ packages: - libgfortran-ng ==15.2.0=*_16 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 27215 timestamp: 1765256845586 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_18.conda @@ -3958,6 +4078,7 @@ packages: - libgfortran 15.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 2480559 timestamp: 1765256819588 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_18.conda @@ -3981,6 +4102,7 @@ packages: - libglvnd 1.7.0 ha4b6fd6_2 - libglx 1.7.0 ha4b6fd6_2 license: LicenseRef-libglvnd + purls: [] size: 134712 timestamp: 1731330998354 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.3-h6548e54_0.conda @@ -3996,6 +4118,7 @@ packages: constrains: - glib 2.86.3 *_0 license: LGPL-2.1-or-later + purls: [] size: 3946542 timestamp: 1765221858705 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.4-h6548e54_1.conda @@ -4011,6 +4134,7 @@ packages: constrains: - glib 2.86.4 *_1 license: LGPL-2.1-or-later + purls: [] size: 4398701 timestamp: 1771863239578 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda @@ -4019,6 +4143,7 @@ packages: depends: - __glibc >=2.17,<3.0.a0 license: LicenseRef-libglvnd + purls: [] size: 132463 timestamp: 1731330968309 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda @@ -4029,25 +4154,9 @@ packages: - libglvnd 1.7.0 ha4b6fd6_2 - xorg-libx11 >=1.8.10,<2.0a0 license: LicenseRef-libglvnd + purls: [] size: 75504 timestamp: 1731330988898 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_15.conda - sha256: b3c4e39be7aba6f5a8695d428362c5c918b96a281ce0a7037f1e889dfc340615 - md5: a90d6983da0757f4c09bb8fcfaf34e71 - depends: - - __glibc >=2.17,<3.0.a0 - license: GPL-3.0-only WITH GCC-exception-3.1 - size: 602978 - timestamp: 1764836011147 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_16.conda - sha256: 5b3e5e4e9270ecfcd48f47e3a68f037f5ab0f529ccb223e8e5d5ac75a58fc687 - md5: 26c46f90d0e727e95c6c9498a33a09f3 - depends: - - __glibc >=2.17,<3.0.a0 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 603284 - timestamp: 1765256703881 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_18.conda sha256: 21337ab58e5e0649d869ab168d4e609b033509de22521de1bfed0c031bfc5110 md5: 239c5e9546c38a1e884d69effcf4c882 @@ -4058,18 +4167,19 @@ packages: purls: [] size: 603262 timestamp: 1771378117851 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda - sha256: 5abe4ab9d93f6c9757d654f1969ae2267d4505315c1f2f8fe705fd60af084f1b - md5: faac990cb7aedc7f3a2224f2c9b0c26c +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + sha256: 62cb599ad0539d99386515326d9d5e8f51f75a60c69c2131b21df76edf35bd89 + md5: 88f2d91cb1533194c323534253094d23 depends: - __glibc >=2.17,<3.0.a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] run_exports: strong: - _openmp_mutex >=4.5 - size: 603817 - timestamp: 1778268942614 + size: 640415 + timestamp: 1785375373755 - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.1-default_hafda6a7_1003.conda sha256: b9e6340da35245d5f3b7b044b4070b4980809d340bddf16c942a97a83f146aa4 md5: 4fe840c6d6b3719b4231ed89d389bb17 @@ -4081,6 +4191,7 @@ packages: - libxml2-16 >=2.14.6 license: BSD-3-Clause license_family: BSD + purls: [] size: 2449346 timestamp: 1765089858592 - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.2-default_hafda6a7_1000.conda @@ -4094,6 +4205,7 @@ packages: - libxml2-16 >=2.14.6 license: BSD-3-Clause license_family: BSD + purls: [] size: 2449916 timestamp: 1765103845133 - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwy-1.3.0-h4c17acf_1.conda @@ -4104,6 +4216,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: Apache-2.0 OR BSD-3-Clause + purls: [] size: 1448617 timestamp: 1758894401402 - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda @@ -4113,6 +4226,7 @@ packages: - __glibc >=2.17,<3.0.a0 - libgcc >=14 license: LGPL-2.1-only + purls: [] size: 790176 timestamp: 1754908768807 - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.2-hb03c661_0.conda @@ -4124,6 +4238,7 @@ packages: constrains: - jpeg <0.0.0a license: IJG AND BSD-3-Clause AND Zlib + purls: [] size: 633710 timestamp: 1762094827865 - conda: https://conda.anaconda.org/conda-forge/linux-64/libjxl-0.11.2-ha09017c_0.conda @@ -4138,6 +4253,7 @@ packages: - libbrotlidec >=1.2.0,<1.3.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1883476 timestamp: 1770801977654 - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-5_h47877c9_openblas.conda @@ -4152,6 +4268,7 @@ packages: - libcblas 3.11.0 5*_openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18200 timestamp: 1765818857876 - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-6_h47877c9_openblas.conda @@ -4178,6 +4295,7 @@ packages: constrains: - xz 5.8.1.* license: 0BSD + purls: [] size: 112894 timestamp: 1749230047870 - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.2-hb03c661_0.conda @@ -4214,6 +4332,7 @@ packages: - libgcc >=14 license: BSD-2-Clause license_family: BSD + purls: [] run_exports: {} size: 92400 timestamp: 1769482286018 @@ -4225,6 +4344,7 @@ packages: - libgcc >=13 license: BSD-2-Clause license_family: BSD + purls: [] size: 91183 timestamp: 1748393666725 - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda @@ -4261,31 +4381,34 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 818615 timestamp: 1761098926897 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-13.3.29-hecca717_0.conda - sha256: 3de6aed48ca7a705aa22444b54ad7236f0e1f9dc7f41ec3e2273e6cb991be213 - md5: 1f9be211f7ec5c88b1d2d561aee7884d +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-12.9.82-hecca717_2.conda + sha256: e044659e3a7e0a3168951fe8c4d7ad0e3b243211037d326d4e62540c75ce010a + md5: 1812ac6d93b3d1079881ccac0615e273 depends: - __glibc >=2.17,<3.0.a0 - - cuda-version >=13.3,<13.4.0a0 + - cuda-version >=12,<12.10.0a0 - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement - size: 472135 - timestamp: 1779897596590 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-13.3.29-hecca717_1.conda - sha256: 2f4f4824d6eb16693fa04aca1f872b64df48445e26e8a357dc538bf9825c25fa - md5: df0f2d96a171e8f843d4f03fa3d8d3d9 + purls: [] + run_exports: {} + size: 818431 + timestamp: 1782920268840 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-13.3.29-hecca717_0.conda + sha256: 3de6aed48ca7a705aa22444b54ad7236f0e1f9dc7f41ec3e2273e6cb991be213 + md5: 1f9be211f7ec5c88b1d2d561aee7884d depends: - __glibc >=2.17,<3.0.a0 - cuda-version >=13.3,<13.4.0a0 - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement - run_exports: {} - size: 470857 - timestamp: 1782920237017 + purls: [] + size: 472135 + timestamp: 1779897596590 - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-12.9.86-hecca717_2.conda sha256: 3b1c851f4fc42d347ce1c1606bdd195343a47f121e0fceb7a1f1e5aa1d497da9 md5: 3461b0f2d5cbb7973d361f9e85241d98 @@ -4295,6 +4418,8 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] + run_exports: {} size: 30515495 timestamp: 1760723776293 - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-13.3.33-hecca717_0.conda @@ -4318,6 +4443,7 @@ packages: - __glibc >=2.17,<3.0.a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 218500 timestamp: 1745825989535 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_4.conda @@ -4332,6 +4458,7 @@ packages: - openblas >=0.3.30,<0.3.31.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 5927939 timestamp: 1763114673331 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.32-pthreads_h94d23a6_0.conda @@ -4358,6 +4485,7 @@ packages: - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 - tbb >=2021.13.0 + purls: [] size: 6244771 timestamp: 1753211097492 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2026.0.0-hb56ce9e_1.conda @@ -4371,6 +4499,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 6582302 timestamp: 1772727204779 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2025.2.0-hed573e4_1.conda @@ -4382,6 +4511,7 @@ packages: - libopenvino 2025.2.0 hb617929_1 - libstdcxx >=14 - tbb >=2021.13.0 + purls: [] size: 114760 timestamp: 1753211116381 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2026.0.0-hd85de46_1.conda @@ -4395,6 +4525,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 114431 timestamp: 1772727230331 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2025.2.0-hed573e4_1.conda @@ -4406,6 +4537,7 @@ packages: - libopenvino 2025.2.0 hb617929_1 - libstdcxx >=14 - tbb >=2021.13.0 + purls: [] size: 250500 timestamp: 1753211127339 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2026.0.0-hd85de46_1.conda @@ -4419,6 +4551,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 249056 timestamp: 1772727247597 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2025.2.0-hd41364c_1.conda @@ -4430,6 +4563,7 @@ packages: - libopenvino 2025.2.0 hb617929_1 - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 + purls: [] size: 194815 timestamp: 1753211138624 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2026.0.0-hd41364c_1.conda @@ -4443,6 +4577,7 @@ packages: - pugixml >=1.15,<1.16.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 211582 timestamp: 1772727264950 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2025.2.0-hb617929_1.conda @@ -4455,6 +4590,7 @@ packages: - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 - tbb >=2021.13.0 + purls: [] size: 12377488 timestamp: 1753211149903 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2026.0.0-hb56ce9e_1.conda @@ -4469,6 +4605,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 13173323 timestamp: 1772727282718 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2025.2.0-hb617929_1.conda @@ -4482,6 +4619,7 @@ packages: - ocl-icd >=2.3.3,<3.0a0 - pugixml >=1.15,<1.16.0a0 - tbb >=2021.13.0 + purls: [] size: 10815480 timestamp: 1753211182626 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2026.0.0-hb56ce9e_1.conda @@ -4497,6 +4635,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 11402462 timestamp: 1772727323957 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2025.2.0-hb617929_1.conda @@ -4510,6 +4649,7 @@ packages: - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 - tbb >=2021.13.0 + purls: [] size: 1261488 timestamp: 1753211212823 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2026.0.0-hb56ce9e_1.conda @@ -4525,6 +4665,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 1994640 timestamp: 1772727360780 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2025.2.0-hd41364c_1.conda @@ -4536,6 +4677,7 @@ packages: - libopenvino 2025.2.0 hb617929_1 - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 + purls: [] size: 204890 timestamp: 1753211224567 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2026.0.0-hd41364c_1.conda @@ -4549,6 +4691,7 @@ packages: - pugixml >=1.15,<1.16.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 192778 timestamp: 1772727380069 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2025.2.0-h1862bb8_1.conda @@ -4562,6 +4705,7 @@ packages: - libopenvino 2025.2.0 hb617929_1 - libprotobuf >=6.31.1,<6.31.2.0a0 - libstdcxx >=14 + purls: [] size: 1724503 timestamp: 1753211235981 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2026.0.0-h7a07914_1.conda @@ -4577,6 +4721,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 1860687 timestamp: 1772727397981 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2025.2.0-h1862bb8_1.conda @@ -4590,6 +4735,7 @@ packages: - libopenvino 2025.2.0 hb617929_1 - libprotobuf >=6.31.1,<6.31.2.0a0 - libstdcxx >=14 + purls: [] size: 744746 timestamp: 1753211248776 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2026.0.0-h7a07914_1.conda @@ -4605,6 +4751,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 684224 timestamp: 1772727417276 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2025.2.0-hecca717_1.conda @@ -4615,6 +4762,7 @@ packages: - libgcc >=14 - libopenvino 2025.2.0 hb617929_1 - libstdcxx >=14 + purls: [] size: 1243134 timestamp: 1753211260154 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2026.0.0-hecca717_1.conda @@ -4627,6 +4775,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 1185558 timestamp: 1772727435039 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2025.2.0-h0767aad_1.conda @@ -4641,6 +4790,7 @@ packages: - libprotobuf >=6.31.1,<6.31.2.0a0 - libstdcxx >=14 - snappy >=1.2.2,<1.3.0a0 + purls: [] size: 1325059 timestamp: 1753211272484 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2026.0.0-h78e8023_1.conda @@ -4657,6 +4807,7 @@ packages: - snappy >=1.2.2,<1.3.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 1257870 timestamp: 1772727453738 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2025.2.0-hecca717_1.conda @@ -4667,6 +4818,7 @@ packages: - libgcc >=14 - libopenvino 2025.2.0 hb617929_1 - libstdcxx >=14 + purls: [] size: 497047 timestamp: 1753211285617 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2026.0.0-hecca717_1.conda @@ -4679,6 +4831,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 456585 timestamp: 1772727473378 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopus-1.5.2-hd0c01bc_0.conda @@ -4689,6 +4842,7 @@ packages: - __glibc >=2.17,<3.0.a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 312472 timestamp: 1744330953241 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopus-1.6.1-h280c20c_0.conda @@ -4699,6 +4853,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 324993 timestamp: 1768497114401 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hb9d3cd8_0.conda @@ -4709,6 +4864,7 @@ packages: - libgcc >=13 license: MIT license_family: MIT + purls: [] size: 28424 timestamp: 1749901812541 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.53-h421ea60_0.conda @@ -4719,6 +4875,7 @@ packages: - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 317748 timestamp: 1764981060755 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.55-h421ea60_0.conda @@ -4729,6 +4886,7 @@ packages: - __glibc >=2.17,<3.0.a0 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 317669 timestamp: 1770691470744 - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.31.1-h49aed37_2.conda @@ -4743,6 +4901,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 4645876 timestamp: 1760550892361 - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.31.1-h49aed37_4.conda @@ -4757,6 +4916,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 4372578 timestamp: 1766316228461 - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.33.5-h2b00c02_0.conda @@ -4771,6 +4931,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 3638698 timestamp: 1769749419271 - conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.60.0-h61e6d4b_0.conda @@ -4787,6 +4948,7 @@ packages: constrains: - __glibc >=2.17 license: LGPL-2.1-or-later + purls: [] size: 3421977 timestamp: 1759327942156 - conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.60.2-h61e6d4b_0.conda @@ -4803,6 +4965,7 @@ packages: constrains: - __glibc >=2.17 license: LGPL-2.1-or-later + purls: [] size: 4011590 timestamp: 1771399906142 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_16.conda @@ -4814,6 +4977,7 @@ packages: - libstdcxx >=15.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 7660762 timestamp: 1765256861607 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_18.conda @@ -4825,22 +4989,23 @@ packages: - libstdcxx >=15.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 8095113 timestamp: 1771378289674 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_19.conda - sha256: 7a58892a52739ce4c0f7109de9e91b4353104748eb04fc6441d88e8af444ba99 - md5: 67eef12ce33f7ff99900c212d7076fc2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-16.1.0-hf2715c6_1.conda + sha256: 85662ecadd3961bc96cbcc38dbc024a768cc35932c8440677ed028ea6322c36c + md5: abd77210925872ee084672cf5be1d491 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=15.2.0 - - libstdcxx >=15.2.0 + - libgcc >=16.1.0 + - libstdcxx >=16.1.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL run_exports: weak: - - libsanitizer 15.2.0 - size: 7930689 - timestamp: 1778269054623 + - libsanitizer 16.1.0 + size: 7780843 + timestamp: 1785375481116 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda sha256: 57cb5f92110324c04498b96563211a1bca6a74b2918b1e8df578bfed03cc32e4 md5: 067590f061c9f6ea7e61e3b2112ed6b3 @@ -4856,6 +5021,7 @@ packages: - mpg123 >=1.32.9,<1.33.0a0 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 355619 timestamp: 1765181778282 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.21-h280c20c_3.conda @@ -4876,6 +5042,7 @@ packages: - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: blessing + purls: [] size: 938979 timestamp: 1764359444435 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.51.1-hf4e2dac_1.conda @@ -4887,6 +5054,7 @@ packages: - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: blessing + purls: [] size: 943451 timestamp: 1766319676469 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.52.0-hf4e2dac_0.conda @@ -4901,42 +5069,20 @@ packages: purls: [] size: 951405 timestamp: 1772818874251 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda - sha256: 365376f4815e5e80def2b3462a2419708b7c292da0da85278386c2618621fff4 - md5: 4aed8e657e9ff156bdbe849b4df44389 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + sha256: 72023efc207fe681e26b65fc9d668062cf0b4f0eacf3431e6eb099b95c1f2efd + md5: df088a279cd5e6fd2790b4c196434da1 depends: - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 - libgcc >=14 - libzlib >=1.3.2,<2.0a0 license: blessing run_exports: weak: - - libsqlite >=3.53.3,<4.0a0 - size: 962119 - timestamp: 1782519076616 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_15.conda - sha256: 2648485aa2dcd5ca385423841a728f262458aec5d814a79da5ab75098e223e3f - md5: fccfb26375ec5e4a2192dee6604b6d02 - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc 15.2.0 he0feb66_15 - constrains: - - libstdcxx-ng ==15.2.0=*_15 - license: GPL-3.0-only WITH GCC-exception-3.1 - size: 5856371 - timestamp: 1764836166363 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_16.conda - sha256: 813427918316a00c904723f1dfc3da1bbc1974c5cfe1ed1e704c6f4e0798cbc6 - md5: 68f68355000ec3f1d6f26ea13e8f525f - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc 15.2.0 he0feb66_16 - constrains: - - libstdcxx-ng ==15.2.0=*_16 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 5856456 - timestamp: 1765256838573 + - libsqlite >=3.53.4,<4.0a0 + size: 964200 + timestamp: 1785016112246 - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_18.conda sha256: 78668020064fdaa27e9ab65cd2997e2c837b564ab26ce3bf0e58a2ce1a525c6e md5: 1b08cd684f34175e4514474793d44bcb @@ -4950,46 +5096,33 @@ packages: purls: [] size: 5852330 timestamp: 1771378262446 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - sha256: dff1058c76ec6b8759e41cefa2508162d00e4a5e6721aa68ec3fd10094e702dc - md5: 5794b3bdc38177caf969dabd3af08549 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + sha256: 79721dd08aeb0ab9e773f1f9ef41cf4e6c17477e3d72319147619045bce05a09 + md5: aed6cf89adc1e9b846e4367ac538e434 depends: - __glibc >=2.17,<3.0.a0 - - libgcc 15.2.0 he0feb66_19 + - libgcc 16.1.0 ha9f2e26_1 constrains: - - libstdcxx-ng ==15.2.0=*_19 + - libstdcxx-ng ==16.1.0=*_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] run_exports: {} - size: 5852044 - timestamp: 1778269036376 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_15.conda - sha256: 2ffaec42c561f53dcc025277043aa02e2557dc0db62bc009be4c7559a7f19f09 - md5: 20a8584ff8677ac9d724345b9d4eb757 - depends: - - libstdcxx 15.2.0 h934c35e_15 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 26905 - timestamp: 1764836222826 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_16.conda - sha256: 81f2f246c7533b41c5e0c274172d607829019621c4a0823b5c0b4a8c7028ee84 - md5: 1b3152694d236cf233b76b8c56bf0eae - depends: - - libstdcxx 15.2.0 h934c35e_16 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 27300 - timestamp: 1765256885128 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_18.conda - sha256: 3c902ffd673cb3c6ddde624cdb80f870b6c835f8bf28384b0016e7d444dd0145 - md5: 6235adb93d064ecdf3d44faee6f468de + size: 6631744 + timestamp: 1785375462643 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.1.0-hdf11a46_1.conda + sha256: 2876ca4463d1b394eb969ce4a84d1620aa63fb8202a6397837d1e45ec76c1208 + md5: c94f06123272d8e129d4acf3a25ffb35 depends: - - libstdcxx 15.2.0 h934c35e_18 + - libstdcxx 16.1.0 h934c35e_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 27575 - timestamp: 1771378314494 + purls: [] + run_exports: + strong: + - libstdcxx + size: 28253 + timestamp: 1785375500257 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.10-hd0affe5_4.conda sha256: f0356bb344a684e7616fc84675cfca6401140320594e8686be30e8ac7547aed2 md5: 1d4c18d75c51ed9d00092a891a547a7d @@ -4998,6 +5131,7 @@ packages: - libcap >=2.77,<2.78.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 491953 timestamp: 1770738638119 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda @@ -5008,6 +5142,7 @@ packages: - libcap >=2.78,<2.79.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] run_exports: {} size: 493022 timestamp: 1780084748140 @@ -5037,6 +5172,7 @@ packages: - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 license: HPND + purls: [] size: 435273 timestamp: 1762022005702 - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.10-hd0affe5_4.conda @@ -5047,6 +5183,7 @@ packages: - libcap >=2.77,<2.78.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 144654 timestamp: 1770738650966 - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda @@ -5057,6 +5194,7 @@ packages: - libcap >=2.78,<2.79.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] run_exports: {} size: 145969 timestamp: 1780084753104 @@ -5080,6 +5218,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 75995 timestamp: 1757032240102 - conda: https://conda.anaconda.org/conda-forge/linux-64/liburing-2.12-hb700be7_0.conda @@ -5091,6 +5230,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 127967 timestamp: 1756125594973 - conda: https://conda.anaconda.org/conda-forge/linux-64/liburing-2.13-hb700be7_0.conda @@ -5102,6 +5242,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 132334 timestamp: 1765872504784 - conda: https://conda.anaconda.org/conda-forge/linux-64/liburing-2.14-hb700be7_0.conda @@ -5113,6 +5254,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 154203 timestamp: 1770566529700 - conda: https://conda.anaconda.org/conda-forge/linux-64/libusb-1.0.29-h73b1eb8_0.conda @@ -5123,6 +5265,7 @@ packages: - libgcc >=13 - libudev1 >=257.4 license: LGPL-2.1-or-later + purls: [] size: 89551 timestamp: 1748856210075 - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-h5347b49_1.conda @@ -5132,6 +5275,7 @@ packages: - __glibc >=2.17,<3.0.a0 - libgcc >=14 license: BSD-3-Clause + purls: [] size: 40235 timestamp: 1764790744114 - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.3-h5347b49_0.conda @@ -5142,6 +5286,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 40311 timestamp: 1766271528534 - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42-h5347b49_0.conda @@ -5186,6 +5331,7 @@ packages: - xorg-libxfixes >=6.0.2,<7.0a0 license: MIT license_family: MIT + purls: [] size: 221308 timestamp: 1765652453244 - conda: https://conda.anaconda.org/conda-forge/linux-64/libvorbis-1.3.7-h54a6638_2.conda @@ -5200,6 +5346,7 @@ packages: - libogg >=1.3.5,<1.4.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 285894 timestamp: 1753879378005 - conda: https://conda.anaconda.org/conda-forge/linux-64/libvpl-2.15.0-h54a6638_1.conda @@ -5214,6 +5361,7 @@ packages: - libva >=2.22.0,<3.0a0 license: MIT license_family: MIT + purls: [] size: 287944 timestamp: 1757278954789 - conda: https://conda.anaconda.org/conda-forge/linux-64/libvpl-2.16.0-h54a6638_0.conda @@ -5227,6 +5375,7 @@ packages: - libva >=2.23.0,<3.0a0 license: MIT license_family: MIT + purls: [] size: 287992 timestamp: 1772980546550 - conda: https://conda.anaconda.org/conda-forge/linux-64/libvpx-1.15.2-hecca717_0.conda @@ -5238,6 +5387,7 @@ packages: - libstdcxx >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 1070048 timestamp: 1762010217363 - conda: https://conda.anaconda.org/conda-forge/linux-64/libvulkan-loader-1.4.328.1-h5279c79_0.conda @@ -5253,6 +5403,7 @@ packages: - libvulkan-headers 1.4.328.1.* license: Apache-2.0 license_family: APACHE + purls: [] size: 197672 timestamp: 1759972155030 - conda: https://conda.anaconda.org/conda-forge/linux-64/libvulkan-loader-1.4.341.0-h5279c79_0.conda @@ -5268,6 +5419,7 @@ packages: - libvulkan-headers 1.4.341.0.* license: Apache-2.0 license_family: APACHE + purls: [] size: 199795 timestamp: 1770077125520 - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda @@ -5280,6 +5432,7 @@ packages: - libwebp 1.6.0 license: BSD-3-Clause license_family: BSD + purls: [] size: 429011 timestamp: 1752159441324 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda @@ -5293,6 +5446,7 @@ packages: - xorg-libxdmcp license: MIT license_family: MIT + purls: [] size: 395888 timestamp: 1727278577118 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda @@ -5318,6 +5472,7 @@ packages: - xorg-libxau >=1.0.12,<2.0a0 license: MIT/X11 Derivative license_family: MIT + purls: [] size: 837922 timestamp: 1764794163823 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.1-ha9997c6_0.conda @@ -5334,6 +5489,7 @@ packages: - libxml2 2.15.1 license: MIT license_family: MIT + purls: [] size: 556302 timestamp: 1761015637262 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.1-hca6bf5a_1.conda @@ -5350,6 +5506,7 @@ packages: - libxml2 2.15.1 license: MIT license_family: MIT + purls: [] size: 555747 timestamp: 1766327145986 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.2-hca6bf5a_0.conda @@ -5366,6 +5523,7 @@ packages: - libxml2 2.15.2 license: MIT license_family: MIT + purls: [] size: 557492 timestamp: 1772704601644 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.1-h26afc86_0.conda @@ -5381,6 +5539,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 45283 timestamp: 1761015644057 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.1-he237659_1.conda @@ -5396,6 +5555,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 45402 timestamp: 1766327161688 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.2-he237659_0.conda @@ -5411,6 +5571,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 45968 timestamp: 1772704614539 - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda @@ -5423,6 +5584,7 @@ packages: - zlib 1.3.1 *_2 license: Zlib license_family: Other + purls: [] size: 60963 timestamp: 1727963148474 - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda @@ -5440,6 +5602,20 @@ packages: - libzlib >=1.3.2,<2.0a0 size: 63629 timestamp: 1774072609062 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + sha256: eb8a0db0aa570124f7d2a93d7c7f596e3390df5e047818d873baad32985fc736 + md5: 0de0122d9570a8ab637c6b73db268389 + depends: + - __glibc >=2.17,<3.0.a0 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 63713 + timestamp: 1785362952714 - conda: https://conda.anaconda.org/conda-forge/linux-64/make-4.4.1-hb9d3cd8_2.conda sha256: d652c7bd4d3b6f82b0f6d063b0d8df6f54cc47531092d7ff008e780f3261bdda md5: 33405d2a66b1411db9f7242c8b97c9e7 @@ -5476,6 +5652,7 @@ packages: - libstdcxx >=13 license: LGPL-2.1-only license_family: LGPL + purls: [] size: 491140 timestamp: 1730581373280 - conda: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.2-py312hd9148b4_1.conda @@ -5532,6 +5709,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 8983459 timestamp: 1763350996398 - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.0-py314h2b28147_0.conda @@ -5550,6 +5729,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 8917806 timestamp: 1766373894725 - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.2-py314h2b28147_1.conda @@ -5568,6 +5749,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 8926994 timestamp: 1770098474394 - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.3-py312h33ff503_0.conda @@ -5599,6 +5782,7 @@ packages: - opencl-headers >=2024.10.24 license: BSD-2-Clause license_family: BSD + purls: [] size: 106742 timestamp: 1743700382939 - conda: https://conda.anaconda.org/conda-forge/linux-64/opencl-headers-2025.06.13-h5888daf_0.conda @@ -5610,6 +5794,7 @@ packages: - libstdcxx >=13 license: Apache-2.0 license_family: APACHE + purls: [] size: 55357 timestamp: 1749853464518 - conda: https://conda.anaconda.org/conda-forge/linux-64/openh264-2.6.0-hc22cd8d_0.conda @@ -5621,6 +5806,7 @@ packages: - libstdcxx >=13 license: BSD-2-Clause license_family: BSD + purls: [] size: 731471 timestamp: 1739400677213 - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.0-h26f9b46_0.conda @@ -5632,6 +5818,7 @@ packages: - libgcc >=14 license: Apache-2.0 license_family: Apache + purls: [] size: 3165399 timestamp: 1762839186699 - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.1-h35e630c_1.conda @@ -5646,9 +5833,9 @@ packages: purls: [] size: 3164551 timestamp: 1769555830639 -- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda - sha256: d48f5c22b9897c01e4dff3680f1f57ceb02711ab9c62f74339b080419dfad34b - md5: 79dd2074b5cd5c5c6b2930514a11e22d +- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + sha256: 012096056b97abf1f68c46b7146bd2cbd68c1be762340b4f5dad4fbbe99177bc + md5: c5955c27917ff2234def47f075e71e02 depends: - __glibc >=2.17,<3.0.a0 - ca-certificates @@ -5658,8 +5845,8 @@ packages: run_exports: weak: - openssl >=3.6.3,<4.0a0 - size: 3159683 - timestamp: 1781069855778 + size: 3182423 + timestamp: 1785913583650 - conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.56.4-hadf4263_0.conda sha256: 3613774ad27e48503a3a6a9d72017087ea70f1426f6e5541dbdb59a3b626eaaf md5: 79f71230c069a287efe3a8614069ddf1 @@ -5678,6 +5865,7 @@ packages: - libpng >=1.6.49,<1.7.0a0 - libzlib >=1.3.1,<2.0a0 license: LGPL-2.1-or-later + purls: [] size: 455420 timestamp: 1751292466873 - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda @@ -5690,6 +5878,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1222481 timestamp: 1763655398280 - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.4-h54a6638_1.conda @@ -5702,6 +5891,7 @@ packages: - __glibc >=2.17,<3.0.a0 license: MIT license_family: MIT + purls: [] size: 450960 timestamp: 1754665235234 - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py312h5253ce2_0.conda @@ -5726,6 +5916,7 @@ packages: - libgcc >=13 license: MIT license_family: MIT + purls: [] size: 8252 timestamp: 1726802366959 - conda: https://conda.anaconda.org/conda-forge/linux-64/pugixml-1.15-h3f63f65_0.conda @@ -5737,6 +5928,7 @@ packages: - libstdcxx >=13 license: MIT license_family: MIT + purls: [] size: 118488 timestamp: 1736601364156 - conda: https://conda.anaconda.org/conda-forge/linux-64/pulseaudio-client-17.0-h9a6aba3_3.conda @@ -5755,6 +5947,7 @@ packages: - pulseaudio 17.0 *_3 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 750785 timestamp: 1763148198088 - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.13-hd63d673_0_cpython.conda @@ -5808,6 +6001,7 @@ packages: - tzdata - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 36768932 timestamp: 1764758363259 python_site_packages_path: lib/python3.14/site-packages @@ -5835,6 +6029,7 @@ packages: - tzdata - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 36790521 timestamp: 1765021515427 python_site_packages_path: lib/python3.14/site-packages @@ -5862,13 +6057,14 @@ packages: - tzdata - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 36702440 timestamp: 1770675584356 python_site_packages_path: lib/python3.14/site-packages -- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda - build_number: 100 - sha256: 6d28ac2b061179deb434d3d57afa98ffd20ec3c5d44ab8048a1ca33424b22d38 - md5: 0b9b2f83b5b600e1ac38becde8d0dd44 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda + build_number: 101 + sha256: ee8f2006e1724b1f2e9e0ccc5a7cfdcab973460faa2f63ac1f6e44fdad4c0344 + md5: 78975a41cf3c525da654f17e35bfca9e depends: - __glibc >=2.17,<3.0.a0 - bzip2 >=1.0.8,<2.0a0 @@ -5878,8 +6074,8 @@ packages: - libgcc >=14 - liblzma >=5.8.3,<6.0a0 - libmpdec >=4.0.0,<5.0a0 - - libsqlite >=3.53.2,<4.0a0 - - libuuid >=2.42.1,<3.0a0 + - libsqlite >=3.53.3,<4.0a0 + - libuuid >=2.42.2,<3.0a0 - libzlib >=1.3.2,<2.0a0 - ncurses >=6.6,<7.0a0 - openssl >=3.5.7,<4.0a0 @@ -5894,8 +6090,8 @@ packages: - python_abi 3.14.* *_cp314 noarch: - python - size: 36717183 - timestamp: 1781255094700 + size: 36869055 + timestamp: 1784910110714 python_site_packages_path: lib/python3.14/site-packages - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py312h8a5da7c_1.conda sha256: cb142bfd92f6e55749365ddc244294fa7b64db6d08c45b018ff1c658907bfcbf @@ -5957,6 +6153,7 @@ packages: - libudev1 >=257.13 license: Linux-OpenIB license_family: BSD + purls: [] run_exports: weak: - rdma-core >=63.0 @@ -5970,6 +6167,7 @@ packages: - ncurses >=6.5,<7.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 282480 timestamp: 1740379431762 - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda @@ -6051,6 +6249,7 @@ packages: - sdl3 >=3.2.22,<4.0a0 - libegl >=1.7.0,<2.0a0 license: Zlib + purls: [] size: 589145 timestamp: 1757842881000 - conda: https://conda.anaconda.org/conda-forge/linux-64/sdl3-3.2.28-h3b84278_0.conda @@ -6078,6 +6277,7 @@ packages: - libxkbcommon >=1.13.0,<2.0a0 - libegl >=1.7.0,<2.0a0 license: Zlib + purls: [] size: 1939082 timestamp: 1764713273386 - conda: https://conda.anaconda.org/conda-forge/linux-64/sdl3-3.2.30-h3b84278_0.conda @@ -6105,6 +6305,7 @@ packages: - libgl >=1.7.0,<2.0a0 - libusb >=1.0.29,<2.0a0 license: Zlib + purls: [] size: 1938719 timestamp: 1767236277588 - conda: https://conda.anaconda.org/conda-forge/linux-64/sdl3-3.4.2-hdeec2a5_0.conda @@ -6134,6 +6335,7 @@ packages: - xorg-libxi >=1.8.2,<2.0a0 - wayland >=1.24.0,<2.0a0 license: Zlib + purls: [] size: 2138749 timestamp: 1771668185803 - conda: https://conda.anaconda.org/conda-forge/linux-64/shaderc-2025.5-h3e344bc_0.conda @@ -6147,6 +6349,7 @@ packages: - spirv-tools >=2025,<2026.0a0 license: Apache-2.0 license_family: Apache + purls: [] size: 113361 timestamp: 1764287965059 - conda: https://conda.anaconda.org/conda-forge/linux-64/shaderc-2025.5-h718be3e_1.conda @@ -6160,6 +6363,7 @@ packages: - spirv-tools >=2026,<2027.0a0 license: Apache-2.0 license_family: Apache + purls: [] size: 113513 timestamp: 1770208767759 - conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.2-h03e3b7b_1.conda @@ -6172,6 +6376,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 45829 timestamp: 1762948049098 - conda: https://conda.anaconda.org/conda-forge/linux-64/spirv-tools-2025.4-hb700be7_0.conda @@ -6185,6 +6390,7 @@ packages: - spirv-headers >=1.4.328.0,<1.4.328.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 2248062 timestamp: 1759805790709 - conda: https://conda.anaconda.org/conda-forge/linux-64/spirv-tools-2026.1-hb700be7_0.conda @@ -6198,6 +6404,7 @@ packages: - spirv-headers >=1.4.341.0,<1.4.341.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 2296977 timestamp: 1770089626195 - conda: https://conda.anaconda.org/conda-forge/linux-64/sqlalchemy-2.0.49-py312h5253ce2_0.conda @@ -6225,6 +6432,7 @@ packages: - libstdcxx >=14 license: BSD-2-Clause license_family: BSD + purls: [] size: 2741200 timestamp: 1756086702093 - conda: https://conda.anaconda.org/conda-forge/linux-64/svt-av1-4.0.1-hecca717_0.conda @@ -6236,6 +6444,7 @@ packages: - libstdcxx >=14 license: BSD-2-Clause license_family: BSD + purls: [] size: 2619743 timestamp: 1769664536467 - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2022.3.0-h8d10470_1.conda @@ -6248,6 +6457,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 181262 timestamp: 1762509955687 - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2022.3.0-hb700be7_2.conda @@ -6260,6 +6470,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 181329 timestamp: 1767886632911 - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda @@ -6287,6 +6498,7 @@ packages: - xorg-libx11 >=1.8.12,<2.0a0 license: TCL license_family: BSD + purls: [] size: 3284905 timestamp: 1763054914403 - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda @@ -6319,19 +6531,19 @@ packages: - pkg:pypi/tornado?source=hash-mapping size: 859665 timestamp: 1774358032165 -- conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.11.29-h2112641_0.conda - sha256: a5b92c2cedcaba3b877d6c4aab42853f57b6bb26f9c901cfb5aa5da03269d310 - md5: 5552b8d0f33cf86753d35da1b3ec0736 +- conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda + sha256: ac2feff703269655286bf163c4382d3c4830bd2eb4e68e77879a8b4939a2203c + md5: 07c4923f2c89939ec82b77f2ab41c5e9 depends: - - libstdcxx >=14 - libgcc >=14 + - libstdcxx >=14 - __glibc >=2.17,<3.0.a0 constrains: - __glibc >=2.17 license: Apache-2.0 OR MIT run_exports: {} - size: 20782187 - timestamp: 1784166603021 + size: 17299962 + timestamp: 1785973451439 - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.24.0-hd6090a7_1.conda sha256: 3aa04ae8e9521d9b56b562376d944c3e52b69f9d2a0667f77b8953464822e125 md5: 035da2e4f5770f036ff704fa17aace24 @@ -6343,6 +6555,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 329779 timestamp: 1761174273487 - conda: https://conda.anaconda.org/conda-forge/linux-64/x264-1!164.3095-h166bdaf_2.tar.bz2 @@ -6352,6 +6565,7 @@ packages: - libgcc-ng >=12 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 897548 timestamp: 1660323080555 - conda: https://conda.anaconda.org/conda-forge/linux-64/x265-3.5-h924138e_3.tar.bz2 @@ -6362,6 +6576,7 @@ packages: - libstdcxx-ng >=10.3.0 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 3357188 timestamp: 1646609687141 - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.46-hb03c661_0.conda @@ -6373,6 +6588,7 @@ packages: - xorg-libx11 >=1.8.12,<2.0a0 license: MIT license_family: MIT + purls: [] size: 396975 timestamp: 1759543819846 - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.47-hb03c661_0.conda @@ -6384,6 +6600,7 @@ packages: - xorg-libx11 >=1.8.13,<2.0a0 license: MIT license_family: MIT + purls: [] size: 399291 timestamp: 1772021302485 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda @@ -6394,6 +6611,7 @@ packages: - libgcc >=13 license: MIT license_family: MIT + purls: [] size: 58628 timestamp: 1734227592886 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.6-he73a12e_0.conda @@ -6406,6 +6624,7 @@ packages: - xorg-libice >=1.1.2,<2.0a0 license: MIT license_family: MIT + purls: [] size: 27590 timestamp: 1741896361728 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.12-h4f16b4b_0.conda @@ -6417,6 +6636,7 @@ packages: - libxcb >=1.17.0,<2.0a0 license: MIT license_family: MIT + purls: [] size: 835896 timestamp: 1741901112627 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.13-he1eb515_0.conda @@ -6428,6 +6648,7 @@ packages: - libxcb >=1.17.0,<2.0a0 license: MIT license_family: MIT + purls: [] size: 839652 timestamp: 1770819209719 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda @@ -6438,6 +6659,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 15321 timestamp: 1762976464266 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda @@ -6451,6 +6673,7 @@ packages: - xorg-libxrender >=0.9.11,<0.10.0a0 license: MIT license_family: MIT + purls: [] size: 32533 timestamp: 1730908305254 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda @@ -6461,6 +6684,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 20591 timestamp: 1762976546182 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.6-hb9d3cd8_0.conda @@ -6472,6 +6696,7 @@ packages: - xorg-libx11 >=1.8.10,<2.0a0 license: MIT license_family: MIT + purls: [] size: 50060 timestamp: 1727752228921 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.7-hb03c661_0.conda @@ -6483,6 +6708,7 @@ packages: - xorg-libx11 >=1.8.12,<2.0a0 license: MIT license_family: MIT + purls: [] size: 50326 timestamp: 1769445253162 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.2-hb03c661_0.conda @@ -6494,6 +6720,7 @@ packages: - xorg-libx11 >=1.8.12,<2.0a0 license: MIT license_family: MIT + purls: [] size: 20071 timestamp: 1759282564045 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.2-hb9d3cd8_0.conda @@ -6507,6 +6734,7 @@ packages: - xorg-libxfixes >=6.0.1,<7.0a0 license: MIT license_family: MIT + purls: [] size: 47179 timestamp: 1727799254088 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.4-hb9d3cd8_0.conda @@ -6520,6 +6748,7 @@ packages: - xorg-libxrender >=0.9.11,<0.10.0a0 license: MIT license_family: MIT + purls: [] size: 29599 timestamp: 1727794874300 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.5-hb03c661_0.conda @@ -6533,6 +6762,7 @@ packages: - xorg-libxrender >=0.9.12,<0.10.0a0 license: MIT license_family: MIT + purls: [] size: 30456 timestamp: 1769445263457 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda @@ -6544,6 +6774,7 @@ packages: - xorg-libx11 >=1.8.10,<2.0a0 license: MIT license_family: MIT + purls: [] size: 33005 timestamp: 1734229037766 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxscrnsaver-1.2.4-hb9d3cd8_0.conda @@ -6556,6 +6787,7 @@ packages: - xorg-libxext >=1.3.6,<2.0a0 license: MIT license_family: MIT + purls: [] size: 14412 timestamp: 1727899730073 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda @@ -6569,6 +6801,7 @@ packages: - xorg-libxi >=1.7.10,<2.0a0 license: MIT license_family: MIT + purls: [] size: 32808 timestamp: 1727964811275 - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda @@ -6636,6 +6869,7 @@ packages: - openmp_impl 9999 license: BSD-3-Clause license_family: BSD + purls: [] size: 23712 timestamp: 1650670790230 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.1-he30d5cf_0.conda @@ -6645,6 +6879,7 @@ packages: - libgcc >=14 license: LGPL-2.1-or-later license_family: GPL + purls: [] size: 615491 timestamp: 1766156819056 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -6654,6 +6889,7 @@ packages: - libgcc >=14 license: LGPL-2.1-or-later license_family: GPL + purls: [] size: 615729 timestamp: 1768327548407 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/aom-3.9.1-hcccb83c_0.conda @@ -6664,6 +6900,7 @@ packages: - libstdcxx-ng >=12 license: BSD-2-Clause license_family: BSD + purls: [] size: 3250813 timestamp: 1718551360260 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/attr-2.5.1-h4e544f5_1.tar.bz2 @@ -6673,6 +6910,7 @@ packages: - libgcc-ng >=12 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 74992 timestamp: 1660065534958 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zstd-1.3.0-py312h3d8e7d4_0.conda @@ -6698,6 +6936,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 4850743 timestamp: 1764007931341 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45-default_h5f4c503_105.conda @@ -6709,6 +6948,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 4848132 timestamp: 1766513201703 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45.1-default_h5f4c503_101.conda @@ -6720,6 +6960,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 4741684 timestamp: 1770267224406 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda @@ -6761,6 +7002,18 @@ packages: - pkg:pypi/brotli?source=hash-mapping size: 373800 timestamp: 1764017545385 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda + sha256: 24eacc8a20fd7c4616566178562bef7f9344eb4a8700cfc3180fa75a6ff9d39f + md5: fd544ef1c672d645bf78e5819cbb8f91 + depends: + - libgcc >=14 + license: bzip2-1.0.6 + license_family: BSD + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 194694 + timestamp: 1785906301397 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_8.conda sha256: d2a296aa0b5f38ed9c264def6cf775c0ccb0f110ae156fcde322f3eccebf2e01 md5: 2921ac0b541bf37c69e66bd6d9a43bca @@ -6768,6 +7021,7 @@ packages: - libgcc >=14 license: bzip2-1.0.6 license_family: BSD + purls: [] size: 192536 timestamp: 1757437302703 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda @@ -6806,6 +7060,7 @@ packages: - xorg-libxext >=1.3.6,<2.0a0 - xorg-libxrender >=0.9.12,<0.10.0a0 license: LGPL-2.1-only or MPL-1.1 + purls: [] size: 927045 timestamp: 1766416003626 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cairo-1.18.4-h83712da_0.conda @@ -6830,6 +7085,7 @@ packages: - xorg-libxext >=1.3.6,<2.0a0 - xorg-libxrender >=0.9.12,<0.10.0a0 license: LGPL-2.1-only or MPL-1.1 + purls: [] size: 966667 timestamp: 1741554768968 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-13.2.0-py312hdc0efb6_0.conda @@ -6865,6 +7121,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23466 timestamp: 1749218349235 @@ -6878,6 +7135,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24782 timestamp: 1779898439985 @@ -6893,6 +7151,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -6910,6 +7169,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=13.3.29,<14.0a0 @@ -6925,6 +7185,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23507 timestamp: 1749218358755 @@ -6938,6 +7199,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24786 timestamp: 1779898447855 @@ -6950,6 +7212,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 33382016 timestamp: 1760723722396 @@ -7010,6 +7273,7 @@ packages: - cuda-nvvm-impl 12.9.86.* - cuda-nvvm-tools 12.9.86.* license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 25585 timestamp: 1771619514901 @@ -7021,6 +7285,7 @@ packages: - cuda-nvvm-impl 13.3.33.* - cuda-nvvm-tools 13.3.33.* license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 25733 timestamp: 1779909827964 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-13.3.73-he9431aa_0.conda @@ -7042,6 +7307,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 21601172 timestamp: 1753975236344 @@ -7075,6 +7341,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24411824 timestamp: 1753975273689 @@ -7086,6 +7353,7 @@ packages: - cuda-version >=13.3,<13.4.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 29031580 timestamp: 1779905175228 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.73-h7b14b0b_0.conda @@ -7107,6 +7375,7 @@ packages: - cuda-cudart-dev - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23784 timestamp: 1761098779882 @@ -7120,6 +7389,7 @@ packages: constrains: - arm-variant * sbsa license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 25101 timestamp: 1779913642980 @@ -7133,6 +7403,8 @@ packages: - python_abi 3.14.* *_cp314 license: Apache-2.0 license_family: APACHE + purls: + - pkg:pypi/cython?source=hash-mapping run_exports: {} size: 3747072 timestamp: 1782821625037 @@ -7151,6 +7423,19 @@ packages: run_exports: {} size: 3649707 timestamp: 1785016066705 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda + sha256: 84aebc300e4a0f4ea697d95ec97277301e83f0a457e61efb48b27a14cfb37bda + md5: 4a44c5167b358f22ae2cd89b07728797 + depends: + - libgcc >=14 + - libstdcxx >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: APACHE + run_exports: {} + size: 3741802 + timestamp: 1785016071504 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dav1d-1.2.1-h31becfc_0.conda sha256: 33fe66d025cf5bac7745196d1a3dd7a437abcf2dbce66043e9745218169f7e17 md5: 6e5a87182d66b2d1328a96b61ca43a62 @@ -7158,6 +7443,7 @@ packages: - libgcc-ng >=12 license: BSD-2-Clause license_family: BSD + purls: [] size: 347363 timestamp: 1685696690003 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda @@ -7170,6 +7456,7 @@ packages: - libzlib >=1.3.1,<2.0a0 - libexpat >=2.7.3,<3.0a0 license: AFL-2.1 OR GPL-2.0-or-later + purls: [] size: 480416 timestamp: 1764536098891 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/debugpy-1.8.20-py312hf55c4e8_0.conda @@ -7243,6 +7530,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 12035194 timestamp: 1773008913159 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ffmpeg-8.0.1-gpl_h936a714_906.conda @@ -7299,6 +7587,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 12009838 timestamp: 1765653483363 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/fontconfig-2.15.0-h8dda3cd_1.conda @@ -7312,6 +7601,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 277832 timestamp: 1730284967179 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/fontconfig-2.17.1-hba86a56_0.conda @@ -7326,6 +7616,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 279044 timestamp: 1771382728182 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/freetype-2.14.1-h8af1aa0_0.conda @@ -7335,6 +7626,7 @@ packages: - libfreetype 2.14.1 h8af1aa0_0 - libfreetype6 2.14.1 hdae7a39_0 license: GPL-2.0-only OR FTL + purls: [] size: 173174 timestamp: 1757945489158 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/freetype-2.14.2-h8af1aa0_0.conda @@ -7344,6 +7636,7 @@ packages: - libfreetype 2.14.2 h8af1aa0_0 - libfreetype6 2.14.2 hdae7a39_0 license: GPL-2.0-only OR FTL + purls: [] size: 173437 timestamp: 1772756019067 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/fribidi-1.0.16-he30d5cf_0.conda @@ -7352,6 +7645,7 @@ packages: depends: - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 62909 timestamp: 1757438620177 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc-15.2.0-h24a549f_16.conda @@ -7363,6 +7657,7 @@ packages: - gcc_no_conda_specs license: BSD-3-Clause license_family: BSD + purls: [] size: 29174 timestamp: 1765257473532 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc-15.2.0-h24a549f_18.conda @@ -7374,25 +7669,9 @@ packages: - gcc_no_conda_specs license: BSD-3-Clause license_family: BSD + purls: [] size: 29408 timestamp: 1771378529822 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda - sha256: cd23829b5fb7f3ff5f44eab2da1a993e06bdf759b681a0a7a73bb5783755b6b3 - md5: 66dfb62e7a47e2b511f9c5ee0ff1abf3 - depends: - - binutils_impl_linux-aarch64 >=2.45 - - libgcc >=15.2.0 - - libgcc-devel_linux-aarch64 15.2.0 h55c397f_119 - - libgomp >=15.2.0 - - libsanitizer 15.2.0 he19c465_19 - - libstdcxx >=15.2.0 - - libstdcxx-devel_linux-aarch64 15.2.0 ha7b1723_119 - - sysroot_linux-aarch64 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - run_exports: {} - size: 73237372 - timestamp: 1778268860495 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-habb1d5c_16.conda sha256: 9b7e56534fa3029e0caf6dbbf4daa2d567e630672f977f01ad0c356933fb1b0d md5: af391ca6347927b4e067a8be221d1b3a @@ -7407,6 +7686,7 @@ packages: - sysroot_linux-aarch64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 74461928 timestamp: 1765257095042 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-hcedddb3_18.conda @@ -7423,22 +7703,40 @@ packages: - sysroot_linux-aarch64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 73516504 timestamp: 1771378256368 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda - sha256: 2450913611189cc3c26062a43a97a93501159335d4d314cca5e2678fb5f4d3b6 - md5: 619b8a05f89220fa8c9536dcfeeddd5b +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-16.1.0-h04da0f0_1.conda + sha256: ad024e118ed57e7277547fd03a913b981e9bb9a6db258b8943293b13329d4489 + md5: e5551bb5b75bcc4031e40f2b69baab84 + depends: + - binutils_impl_linux-aarch64 >=2.46.1 + - libgcc >=16.1.0 + - libgcc-devel_linux-aarch64 16.1.0 hd673532_101 + - libgomp >=16.1.0 + - libsanitizer 16.1.0 h2510bd8_1 + - libstdcxx >=16.1.0 + - libstdcxx-devel_linux-aarch64 16.1.0 h2445e1f_101 + - sysroot_linux-aarch64 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 75102801 + timestamp: 1785374604361 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-16.1.0-hed00b63_0.conda + sha256: 50305dd8c4198b4a38fca1666589bdaba0d26cf2c69f901391259d5b4b1133a4 + md5: 4cb863693c93536916f84802ea2b520c depends: - - gcc_impl_linux-aarch64 15.2.0.* + - gcc_impl_linux-aarch64 16.1.0.* - binutils_linux-aarch64 - sysroot_linux-aarch64 license: BSD-3-Clause license_family: BSD run_exports: strong: - - libgcc >=15 - size: 29074 - timestamp: 1781279974207 + - libgcc >=16 + size: 29478 + timestamp: 1785386542583 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gdk-pixbuf-2.44.4-h90308e0_0.conda sha256: 78a1d69c3d0da73b4d54a35001abd4e273605180d21365b4f31e9a241d9fb715 md5: 4c8c0d2f7620467869d41f29304362dc @@ -7451,6 +7749,7 @@ packages: - libtiff >=4.7.1,<4.8.0a0 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 580454 timestamp: 1761083738779 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gdk-pixbuf-2.44.5-h90308e0_1.conda @@ -7465,6 +7764,7 @@ packages: - libtiff >=4.7.1,<4.8.0a0 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 584221 timestamp: 1771532437279 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/glslang-16.1.0-hd1da3a6_0.conda @@ -7476,6 +7776,7 @@ packages: - spirv-tools >=2025,<2026.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1308404 timestamp: 1764720598114 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/glslang-16.2.0-h124e036_1.conda @@ -7487,6 +7788,7 @@ packages: - spirv-tools >=2026,<2027.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1348415 timestamp: 1770195275881 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gmp-6.3.0-h0a1ffab_2.conda @@ -7496,6 +7798,7 @@ packages: - libgcc-ng >=12 - libstdcxx-ng >=12 license: GPL-2.0-or-later OR LGPL-3.0-or-later + purls: [] size: 417323 timestamp: 1718980707330 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/graphite2-1.3.14-hfae3067_2.conda @@ -7506,6 +7809,7 @@ packages: - libstdcxx >=14 license: LGPL-2.0-or-later license_family: LGPL + purls: [] size: 102400 timestamp: 1755102000043 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/greenlet-3.3.2-py312hf55c4e8_0.conda @@ -7531,6 +7835,7 @@ packages: - gxx_impl_linux-aarch64 15.2.0 h03e2352_16 license: BSD-3-Clause license_family: BSD + purls: [] size: 28544 timestamp: 1765257509084 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx-15.2.0-ha384071_18.conda @@ -7541,6 +7846,7 @@ packages: - gxx_impl_linux-aarch64 15.2.0 h03e2352_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 28780 timestamp: 1771378557194 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_16.conda @@ -7553,6 +7859,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 14627102 timestamp: 1765257416069 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_18.conda @@ -7565,37 +7872,38 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 15371317 timestamp: 1771378487467 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda - sha256: afb0fc36b93539a8e43a8063c8d3e1b4bace38a5a0c3c9e1978c72792d633c62 - md5: 7214ae8a8aade7b48a2bfd8bbb4d9e79 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-16.1.0-hd5c6868_1.conda + sha256: 9a8b38dc912b6952e52b554e1eb851da279fd4ead6fee7eac78ee2397be19d40 + md5: b7d0e87c50859580781ed98eb0a70180 depends: - - gcc_impl_linux-aarch64 15.2.0 h3530432_19 - - libstdcxx-devel_linux-aarch64 15.2.0 ha7b1723_119 + - gcc_impl_linux-aarch64 16.1.0 h04da0f0_1 + - libstdcxx-devel_linux-aarch64 16.1.0 h2445e1f_101 - sysroot_linux-aarch64 - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL run_exports: {} - size: 14640001 - timestamp: 1778269082840 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda - sha256: f4bc63d467e2c48c255bc8d2886fb11f6a8d09c1251a6f5b25628abee1768693 - md5: ea51d6df068bee183ff667f75bfdc2f6 - depends: - - gxx_impl_linux-aarch64 15.2.0.* - - gcc_linux-aarch64 ==15.2.0 h0bf4bd8_27 + size: 15592564 + timestamp: 1785374786297 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-16.1.0-h4223dcb_0.conda + sha256: edfc3ee04478cdfed6b84f58bc1db77818ed92f1d58bd6de565e9a8bacb5a558 + md5: 036c35401710f4b03aba2a0cc5792496 + depends: + - gxx_impl_linux-aarch64 16.1.0.* + - gcc_linux-aarch64 ==16.1.0 hed00b63_0 - binutils_linux-aarch64 - sysroot_linux-aarch64 license: BSD-3-Clause license_family: BSD run_exports: strong: - - libstdcxx >=15 - - libgcc >=15 - size: 27620 - timestamp: 1781279974207 + - libstdcxx >=16 + - libgcc >=16 + size: 27895 + timestamp: 1785386542583 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/harfbuzz-12.2.0-he4899c9_0.conda sha256: 5cfd74a3fbce0921af5beff93a3fe7edc5b1344d9b9668b2de1c1be932b54993 md5: 1437bf9690976948f90175a65407b65f @@ -7612,6 +7920,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 2156041 timestamp: 1762376447693 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/harfbuzz-12.3.0-h1134a53_0.conda @@ -7630,6 +7939,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 2454001 timestamp: 1766941218362 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/harfbuzz-13.1.0-h1134a53_0.conda @@ -7648,6 +7958,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 2346492 timestamp: 1773222371375 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-75.1-hf9b3779_0.conda @@ -7658,6 +7969,7 @@ packages: - libstdcxx-ng >=12 license: MIT license_family: MIT + purls: [] size: 12282786 timestamp: 1720853454991 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.1-hb1525cb_0.conda @@ -7668,6 +7980,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 12835377 timestamp: 1766304007889 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.2-hcab7f73_0.conda @@ -7678,6 +7991,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 12851689 timestamp: 1772208964788 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda @@ -7691,18 +8005,6 @@ packages: purls: [] size: 12837286 timestamp: 1773822650615 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda - sha256: ba4e1acdaf6c66961d6a1863c10851dde2378fa18af48de0156b9874556ca438 - md5: da55da4ed68dcac1ce28faa0a3450b65 - depends: - - libgcc >=14 - - libstdcxx >=14 - license: MIT - run_exports: - weak: - - icu >=78.3,<79.0a0 - size: 12870753 - timestamp: 1784588696185 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/keyutils-1.6.3-h86ecc28_0.conda sha256: 5ce830ca274b67de11a7075430a72020c1fb7d486161a82839be15c2b84e9988 md5: e7df0aab10b9cbb73ab2a467ebfaf8c7 @@ -7734,6 +8036,7 @@ packages: - libgcc-ng >=12 license: LGPL-2.0-only license_family: LGPL + purls: [] size: 604863 timestamp: 1664997611416 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45-default_h1979696_104.conda @@ -7745,6 +8048,7 @@ packages: - binutils_impl_linux-aarch64 2.45 license: GPL-3.0-only license_family: GPL + purls: [] size: 875534 timestamp: 1764007911054 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45-default_h1979696_105.conda @@ -7756,6 +8060,7 @@ packages: - binutils_impl_linux-aarch64 2.45 license: GPL-3.0-only license_family: GPL + purls: [] size: 876257 timestamp: 1766513180236 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_101.conda @@ -7767,6 +8072,7 @@ packages: - binutils_impl_linux-aarch64 2.45.1 license: GPL-3.0-only license_family: GPL + purls: [] size: 875924 timestamp: 1770267209884 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda @@ -7801,6 +8107,7 @@ packages: - libstdcxx >=13 license: Apache-2.0 license_family: Apache + purls: [] size: 227184 timestamp: 1745265544057 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lerc-4.1.0-h52b7260_0.conda @@ -7811,6 +8118,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: Apache + purls: [] size: 240444 timestamp: 1773114901155 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20250512.1-cxx17_h201e9ed_0.conda @@ -7824,6 +8132,7 @@ packages: - libabseil-static =20250512.1=cxx17* license: Apache-2.0 license_family: Apache + purls: [] size: 1327580 timestamp: 1750194149128 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20260107.1-cxx17_h6983b43_0.conda @@ -7837,6 +8146,7 @@ packages: - libabseil-static =20260107.1=cxx17* license: Apache-2.0 license_family: Apache + purls: [] size: 1401836 timestamp: 1770863223557 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libass-0.17.4-hcfe818d_0.conda @@ -7853,6 +8163,7 @@ packages: - libfreetype6 >=2.13.3 - libzlib >=1.3.1,<2.0a0 license: ISC + purls: [] size: 171287 timestamp: 1749328949722 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-5_haddc8a3_openblas.conda @@ -7870,6 +8181,7 @@ packages: - blas 2.305 openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18369 timestamp: 1765818610617 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-6_haddc8a3_openblas.conda @@ -7897,6 +8209,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 80030 timestamp: 1764017273715 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlidec-1.2.0-he30d5cf_1.conda @@ -7907,6 +8220,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 33166 timestamp: 1764017282936 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlienc-1.2.0-he30d5cf_1.conda @@ -7917,6 +8231,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 309304 timestamp: 1764017292044 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.77-h68e9139_0.conda @@ -7927,6 +8242,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 108542 timestamp: 1762350753349 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.77-hf9559e3_1.conda @@ -7946,11 +8262,24 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] run_exports: weak: - libcap >=2.78,<2.79.0a0 size: 109192 timestamp: 1775490102029 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hfcc8634_1.conda + sha256: 6487e7644d062e18d389c11a9a3183e5a71c2652d05fdd88dbd063ad09f7ad4b + md5: 5e347c665a310b4c148bbb02596ae0c3 + depends: + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libcap >=2.78,<2.79.0a0 + size: 108530 + timestamp: 1786025925536 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-5_hd72aa62_openblas.conda build_number: 5 sha256: 3fad5c9de161dccb4e42c8b1ae8eccb33f4ed56bccbcced9cbb0956ae7869e61 @@ -7963,6 +8292,7 @@ packages: - blas 2.305 openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18371 timestamp: 1765818618899 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-6_hd72aa62_openblas.conda @@ -7991,6 +8321,7 @@ packages: - libstdcxx >=14 - rdma-core >=59.0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 909365 timestamp: 1761098964619 @@ -8023,6 +8354,7 @@ packages: constrains: - arm-variant * sbsa license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 997204 timestamp: 1782772368681 @@ -8070,6 +8402,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 71117 timestamp: 1761979776756 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdrm-2.4.125-he30d5cf_1.conda @@ -8080,6 +8413,7 @@ packages: - libpciaccess >=0.18,<0.19.0a0 license: MIT license_family: MIT + purls: [] size: 344548 timestamp: 1757212128414 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libedit-3.1.20250104-pl5321h976ea20_0.conda @@ -8100,6 +8434,7 @@ packages: depends: - libglvnd 1.7.0 hd24410f_2 license: LicenseRef-libglvnd + purls: [] size: 53551 timestamp: 1731330990477 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.7.3-hfae3067_0.conda @@ -8111,6 +8446,7 @@ packages: - expat 2.7.3.* license: MIT license_family: MIT + purls: [] size: 76201 timestamp: 1763549910086 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.7.4-hfae3067_0.conda @@ -8122,6 +8458,7 @@ packages: - expat 2.7.4.* license: MIT license_family: MIT + purls: [] size: 76564 timestamp: 1771259530958 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.7.5-hfae3067_0.conda @@ -8168,6 +8505,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 55586 timestamp: 1760295405021 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libflac-1.5.0-he9c94f4_1.conda @@ -8180,6 +8518,7 @@ packages: - libstdcxx >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 397272 timestamp: 1764526699497 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.1-h8af1aa0_0.conda @@ -8188,6 +8527,7 @@ packages: depends: - libfreetype6 >=2.14.1 license: GPL-2.0-only OR FTL + purls: [] size: 7753 timestamp: 1757945484817 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.2-h8af1aa0_0.conda @@ -8196,6 +8536,7 @@ packages: depends: - libfreetype6 >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 8108 timestamp: 1772756012710 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.1-hdae7a39_0.conda @@ -8208,6 +8549,7 @@ packages: constrains: - freetype >=2.14.1 license: GPL-2.0-only OR FTL + purls: [] size: 423210 timestamp: 1757945484108 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.2-hdae7a39_0.conda @@ -8220,31 +8562,9 @@ packages: constrains: - freetype >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 423372 timestamp: 1772756012086 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_15.conda - sha256: ff184dbe54493b663eab2d62fa0b5a689eb84bec6401fcaeb44265c7f31ae4c6 - md5: cfdf8700e69902a113f2611e3cc09b55 - depends: - - _openmp_mutex >=4.5 - constrains: - - libgcc-ng ==15.2.0=*_15 - - libgomp 15.2.0 h8acb6b2_15 - license: GPL-3.0-only WITH GCC-exception-3.1 - size: 621200 - timestamp: 1764836146613 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_16.conda - sha256: 44bfc6fe16236babb271e0c693fe7fd978f336542e23c9c30e700483796ed30b - md5: cf9cd6739a3b694dcf551d898e112331 - depends: - - _openmp_mutex >=4.5 - constrains: - - libgomp 15.2.0 h8acb6b2_16 - - libgcc-ng ==15.2.0=*_16 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 620637 - timestamp: 1765256938043 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_18.conda sha256: 43df385bedc1cab11993c4369e1f3b04b4ca5d0ea16cba6a0e7f18dbc129fcc9 md5: 552567ea2b61e3a3035759b2fdb3f9a6 @@ -8258,36 +8578,20 @@ packages: purls: [] size: 622900 timestamp: 1771378128706 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - sha256: 4592b096e553f67799ae70d4b6167eeda3ec74587d68c7aecbf4e7b1df136681 - md5: f35b3f52d0a2ec4ffe3c89ba135cdb9a +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + sha256: 88a3d400c678df034c9d498f32503779977d5ea826063687c663e42c945abed5 + md5: 91eb209af1098d652fc69b8a3fc7cbaa depends: - _openmp_mutex >=4.5 constrains: - - libgomp 15.2.0 h8acb6b2_19 - - libgcc-ng ==15.2.0=*_19 + - libgomp 16.1.0 h8acb6b2_1 + - libgcc-ng ==16.1.0=*_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] run_exports: {} - size: 622462 - timestamp: 1778268755949 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_15.conda - sha256: 80e6135b5b0083ad6f0f00b8368d666fb148923fe2d3ab7d8cdca3eaf575eeff - md5: ad92990dc6f608f412a01540a7c9510e - depends: - - libgcc 15.2.0 h8acb6b2_15 - license: GPL-3.0-only WITH GCC-exception-3.1 - size: 26927 - timestamp: 1764836155568 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_16.conda - sha256: 22d7e63a00c880bd14fbbc514ec6f553b9325d705f08582e9076c7e73c93a2e1 - md5: 3e54a6d0f2ff0172903c0acfda9efc0e - depends: - - libgcc 15.2.0 h8acb6b2_16 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 27356 - timestamp: 1765256948637 + size: 628785 + timestamp: 1785374520532 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_18.conda sha256: 83bb0415f59634dccfa8335d4163d1f6db00a27b36666736f9842b650b92cf2f md5: 4feebd0fbf61075a1a9c2e9b3936c257 @@ -8298,6 +8602,19 @@ packages: purls: [] size: 27568 timestamp: 1771378136019 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-16.1.0-he9431aa_1.conda + sha256: e0456b4b49e8f9f9ffc04b1b412101ea2c38476eaceb9a0e4e16792d7cfdd929 + md5: e4489d8717b51cee8a33f2b66d10fa6a + depends: + - libgcc 16.1.0 h205dda4_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libgcc + size: 28123 + timestamp: 1785374523851 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_16.conda sha256: 02fa489a333ee4bb5483ae6bf221386b67c25d318f2f856237821a7c9333d5be md5: 776cca322459d09aad229a49761c0654 @@ -8307,6 +8624,7 @@ packages: - libgfortran-ng ==15.2.0=*_16 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 27314 timestamp: 1765256989755 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_18.conda @@ -8330,6 +8648,7 @@ packages: - libgfortran 15.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 1485817 timestamp: 1765256963205 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_18.conda @@ -8351,6 +8670,7 @@ packages: - libglvnd 1.7.0 hd24410f_2 - libglx 1.7.0 hd24410f_2 license: LicenseRef-libglvnd + purls: [] size: 145442 timestamp: 1731331005019 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.3-hf53f6bf_0.conda @@ -8365,6 +8685,7 @@ packages: constrains: - glib 2.86.3 *_0 license: LGPL-2.1-or-later + purls: [] size: 4041779 timestamp: 1765221790843 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.4-hf53f6bf_1.conda @@ -8379,12 +8700,14 @@ packages: constrains: - glib 2.86.4 *_1 license: LGPL-2.1-or-later + purls: [] size: 4512186 timestamp: 1771863220969 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_2.conda sha256: 57ec3898a923d4bcc064669e90e8abfc4d1d945a13639470ba5f3748bd3090da md5: 9e115653741810778c9a915a2f8439e7 license: LicenseRef-libglvnd + purls: [] size: 152135 timestamp: 1731330986070 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_2.conda @@ -8394,21 +8717,9 @@ packages: - libglvnd 1.7.0 hd24410f_2 - xorg-libx11 >=1.8.9,<2.0a0 license: LicenseRef-libglvnd + purls: [] size: 77736 timestamp: 1731330998960 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_15.conda - sha256: d76cbb7e76af310828c74396a78c59a3b305431da25c9337e420bb441d2e8ca0 - md5: 0719da240fd6086c34c4c30080329806 - license: GPL-3.0-only WITH GCC-exception-3.1 - size: 587301 - timestamp: 1764836050907 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_16.conda - sha256: 0a9d77c920db691eb42b78c734d70c5a1d00b3110c0867cfff18e9dd69bc3c29 - md5: 4d2f224e8186e7881d53e3aead912f6c - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 587924 - timestamp: 1765256821307 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_18.conda sha256: fc716f11a6a8525e27a5d332ef6a689210b0d2a4dd1133edc0f530659aa9faa6 md5: 4faa39bf919939602e594253bd673958 @@ -8417,16 +8728,17 @@ packages: purls: [] size: 588060 timestamp: 1771378040807 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda - sha256: 2370ef0ffcbae5bede3c4bf136add4abc257245eb91f724c99bb4a43116c5a83 - md5: c5e8a379c4a2ec2aea4ba22758c001d9 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + sha256: 1c609a4a72597350317b92c4d9dfb85d21740219048e2b1d458925a6ccfa3d7a + md5: 4c9b02fc9fe27704777e260157003653 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] run_exports: strong: - _openmp_mutex >=4.5 - size: 587387 - timestamp: 1778268674393 + size: 617180 + timestamp: 1785374444877 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.1-default_ha470c98_1003.conda sha256: f0d2fdf4480bac454ac4585fbb8283dde72b8140e6767f9f0009bbf4aedd2db6 md5: da82e5681665613cd336ee8a7b7b87de @@ -8437,6 +8749,7 @@ packages: - libxml2-16 >=2.14.6 license: BSD-3-Clause license_family: BSD + purls: [] size: 2465783 timestamp: 1765090029212 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.2-default_ha470c98_1000.conda @@ -8449,6 +8762,7 @@ packages: - libxml2-16 >=2.14.6 license: BSD-3-Clause license_family: BSD + purls: [] size: 2467105 timestamp: 1765103804193 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwy-1.3.0-h81d0cf9_1.conda @@ -8458,6 +8772,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: Apache-2.0 OR BSD-3-Clause + purls: [] size: 1180000 timestamp: 1758894754411 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda @@ -8466,6 +8781,7 @@ packages: depends: - libgcc >=14 license: LGPL-2.1-only + purls: [] size: 791226 timestamp: 1754910975665 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.2-he30d5cf_0.conda @@ -8476,6 +8792,7 @@ packages: constrains: - jpeg <0.0.0a license: IJG AND BSD-3-Clause AND Zlib + purls: [] size: 691818 timestamp: 1762094728337 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjxl-0.11.2-h71be66a_0.conda @@ -8489,6 +8806,7 @@ packages: - libhwy >=1.3.0,<1.4.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1489440 timestamp: 1770801995062 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.11.0-5_h88aeb00_openblas.conda @@ -8503,6 +8821,7 @@ packages: - libcblas 3.11.0 5*_openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18392 timestamp: 1765818627104 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.11.0-6_h88aeb00_openblas.conda @@ -8528,6 +8847,7 @@ packages: constrains: - xz 5.8.1.* license: 0BSD + purls: [] size: 125103 timestamp: 1749232230009 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.2-he30d5cf_0.conda @@ -8561,6 +8881,7 @@ packages: - libgcc >=13 license: BSD-2-Clause license_family: BSD + purls: [] size: 114064 timestamp: 1748393729243 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda @@ -8570,6 +8891,7 @@ packages: - libgcc >=14 license: BSD-2-Clause license_family: BSD + purls: [] run_exports: {} size: 114056 timestamp: 1769482343003 @@ -8605,24 +8927,25 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 770989 timestamp: 1761098866337 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_0.conda - sha256: a811726bc62a3e1952672aa0917166f8123e0ff2c182b9346384f8e962184530 - md5: 3ace0e6476f8c17381dc3b391c3c5049 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-12.9.82-h8f3c8d4_2.conda + sha256: 11a041920935c01fce0cc351f5db4157a3154e9a1aa3cfec29a707fb44c9a112 + md5: 230f26daf9cfcf4a4185c0c6f9cbdcb2 depends: - arm-variant * sbsa - - cuda-version >=13.3,<13.4.0a0 + - cuda-version >=12,<12.10.0a0 - libgcc >=14 - libstdcxx >=14 - constrains: - - arm-variant * sbsa license: LicenseRef-NVIDIA-End-User-License-Agreement - size: 459700 - timestamp: 1779897643320 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_1.conda - sha256: 5a5f13012bde038ad880d7af1514cc9fb6aa50dbffd69ab57e9b20914a3a5e59 - md5: c27b87f23e6381ebbb7f899bdfbe159c + purls: [] + run_exports: {} + size: 771344 + timestamp: 1782920321153 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_0.conda + sha256: a811726bc62a3e1952672aa0917166f8123e0ff2c182b9346384f8e962184530 + md5: 3ace0e6476f8c17381dc3b391c3c5049 depends: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 @@ -8631,9 +8954,9 @@ packages: constrains: - arm-variant * sbsa license: LicenseRef-NVIDIA-End-User-License-Agreement - run_exports: {} - size: 458764 - timestamp: 1782920269581 + purls: [] + size: 459700 + timestamp: 1779897643320 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-12.9.86-h8f3c8d4_2.conda sha256: d5ff36f46250069a23b18d557052c6656f40a002333885e8c5332071e873b48e md5: e318a6573fea150226d5f417d1c0807a @@ -8643,6 +8966,8 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] + run_exports: {} size: 30323952 timestamp: 1760723774770 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-13.3.33-h8f3c8d4_0.conda @@ -8667,6 +8992,7 @@ packages: - libgcc >=13 license: BSD-3-Clause license_family: BSD + purls: [] size: 220653 timestamp: 1745826021156 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.30-pthreads_h9d3fd7e_4.conda @@ -8680,6 +9006,7 @@ packages: - openblas >=0.3.30,<0.3.31.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 4959359 timestamp: 1763114173544 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.32-pthreads_h9d3fd7e_0.conda @@ -8704,6 +9031,7 @@ packages: - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 - tbb >=2021.13.0 + purls: [] size: 5535917 timestamp: 1753203182299 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-2026.0.0-h1915271_1.conda @@ -8716,6 +9044,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 5742222 timestamp: 1772721263739 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-arm-cpu-plugin-2025.2.0-hcd21e76_1.conda @@ -8727,6 +9056,7 @@ packages: - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 - tbb >=2021.13.0 + purls: [] size: 9257629 timestamp: 1753203203327 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-arm-cpu-plugin-2026.0.0-h1915271_1.conda @@ -8740,6 +9070,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 10237615 timestamp: 1772721303162 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-auto-batch-plugin-2025.2.0-h3890994_1.conda @@ -8750,6 +9081,7 @@ packages: - libopenvino 2025.2.0 hcd21e76_1 - libstdcxx >=14 - tbb >=2021.13.0 + purls: [] size: 111599 timestamp: 1753203233477 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-auto-batch-plugin-2026.0.0-h3d5001d_1.conda @@ -8762,6 +9094,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 111064 timestamp: 1772721336786 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-auto-plugin-2025.2.0-h3890994_1.conda @@ -8772,6 +9105,7 @@ packages: - libopenvino 2025.2.0 hcd21e76_1 - libstdcxx >=14 - tbb >=2021.13.0 + purls: [] size: 235379 timestamp: 1753203244808 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-auto-plugin-2026.0.0-h3d5001d_1.conda @@ -8784,6 +9118,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 236010 timestamp: 1772721351244 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-hetero-plugin-2025.2.0-he07c6df_1.conda @@ -8794,6 +9129,7 @@ packages: - libopenvino 2025.2.0 hcd21e76_1 - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 + purls: [] size: 187747 timestamp: 1753203256494 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-hetero-plugin-2026.0.0-he07c6df_1.conda @@ -8806,6 +9142,7 @@ packages: - pugixml >=1.15,<1.16.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 202574 timestamp: 1772721365749 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-ir-frontend-2025.2.0-he07c6df_1.conda @@ -8816,6 +9153,7 @@ packages: - libopenvino 2025.2.0 hcd21e76_1 - libstdcxx >=14 - pugixml >=1.15,<1.16.0a0 + purls: [] size: 195451 timestamp: 1753203267888 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-ir-frontend-2026.0.0-he07c6df_1.conda @@ -8828,6 +9166,7 @@ packages: - pugixml >=1.15,<1.16.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 185648 timestamp: 1772721380070 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-onnx-frontend-2025.2.0-h07d5dce_1.conda @@ -8840,6 +9179,7 @@ packages: - libopenvino 2025.2.0 hcd21e76_1 - libprotobuf >=6.31.1,<6.31.2.0a0 - libstdcxx >=14 + purls: [] size: 1530030 timestamp: 1753203281815 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-onnx-frontend-2026.0.0-h558496d_1.conda @@ -8854,6 +9194,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 1665115 timestamp: 1772721394860 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-paddle-frontend-2025.2.0-h07d5dce_1.conda @@ -8866,6 +9207,7 @@ packages: - libopenvino 2025.2.0 hcd21e76_1 - libprotobuf >=6.31.1,<6.31.2.0a0 - libstdcxx >=14 + purls: [] size: 674194 timestamp: 1753203295461 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-paddle-frontend-2026.0.0-h558496d_1.conda @@ -8880,6 +9222,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 631754 timestamp: 1772721411589 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-pytorch-frontend-2025.2.0-hfae3067_1.conda @@ -8889,6 +9232,7 @@ packages: - libgcc >=14 - libopenvino 2025.2.0 hcd21e76_1 - libstdcxx >=14 + purls: [] size: 1123835 timestamp: 1753203307507 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-pytorch-frontend-2026.0.0-hfae3067_1.conda @@ -8900,6 +9244,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 1091266 timestamp: 1772721428223 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-tensorflow-frontend-2025.2.0-h38473e3_1.conda @@ -8913,6 +9258,7 @@ packages: - libprotobuf >=6.31.1,<6.31.2.0a0 - libstdcxx >=14 - snappy >=1.2.2,<1.3.0a0 + purls: [] size: 1224816 timestamp: 1753203320621 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-tensorflow-frontend-2026.0.0-h2cb6e3c_1.conda @@ -8928,6 +9274,7 @@ packages: - snappy >=1.2.2,<1.3.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 1184078 timestamp: 1772721443833 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-tensorflow-lite-frontend-2025.2.0-hfae3067_1.conda @@ -8937,6 +9284,7 @@ packages: - libgcc >=14 - libopenvino 2025.2.0 hcd21e76_1 - libstdcxx >=14 + purls: [] size: 456714 timestamp: 1753203333676 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-tensorflow-lite-frontend-2026.0.0-hfae3067_1.conda @@ -8948,6 +9296,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 428895 timestamp: 1772721459028 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopus-1.5.2-h86ecc28_0.conda @@ -8957,6 +9306,7 @@ packages: - libgcc >=13 license: BSD-3-Clause license_family: BSD + purls: [] size: 357115 timestamp: 1744331282621 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopus-1.6.1-h80f16a2_0.conda @@ -8966,6 +9316,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 383586 timestamp: 1768497303687 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpciaccess-0.18-h86ecc28_0.conda @@ -8975,6 +9326,7 @@ packages: - libgcc >=13 license: MIT license_family: MIT + purls: [] size: 29512 timestamp: 1749901899881 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpng-1.6.53-h1abf092_0.conda @@ -8984,6 +9336,7 @@ packages: - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 340043 timestamp: 1764981067899 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpng-1.6.55-h1abf092_0.conda @@ -8993,6 +9346,7 @@ packages: - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 340156 timestamp: 1770691477245 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.31.1-h2cf3c76_2.conda @@ -9006,6 +9360,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 4465754 timestamp: 1760550264433 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.31.1-h2cf3c76_4.conda @@ -9019,6 +9374,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 4218080 timestamp: 1766315327959 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.33.5-h1f88751_0.conda @@ -9032,6 +9388,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 3465308 timestamp: 1769748410724 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/librsvg-2.60.0-h8171147_0.conda @@ -9047,6 +9404,7 @@ packages: constrains: - __glibc >=2.17 license: LGPL-2.1-or-later + purls: [] size: 2995492 timestamp: 1759335330016 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/librsvg-2.60.2-h8171147_0.conda @@ -9062,6 +9420,7 @@ packages: constrains: - __glibc >=2.17 license: LGPL-2.1-or-later + purls: [] size: 4016799 timestamp: 1771406266442 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_16.conda @@ -9072,6 +9431,7 @@ packages: - libstdcxx >=15.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 7460968 timestamp: 1765257008136 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_18.conda @@ -9082,21 +9442,22 @@ packages: - libstdcxx >=15.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 7164557 timestamp: 1771378185265 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda - sha256: 8115604f113fe2b7be95b2d22183a4dda5779c1cc6db4b826af800581498b4b3 - md5: 95210a1edbd7fc6e12afc9f8276f450a +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-16.1.0-h2510bd8_1.conda + sha256: 3dfccbcd3bf34923df7482df41bcdbe599675f2de6f03a554dbc238476693854 + md5: ae3d9771453f2ec660dd79e5728129b3 depends: - - libgcc >=15.2.0 - - libstdcxx >=15.2.0 + - libgcc >=16.1.0 + - libstdcxx >=16.1.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL run_exports: weak: - - libsanitizer 15.2.0 - size: 7067965 - timestamp: 1778268796086 + - libsanitizer 16.1.0 + size: 8123895 + timestamp: 1785374560390 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsndfile-1.2.2-h30591a0_2.conda sha256: f0b6844c09cdec608ca504bd97c5d64a5596a25f66ad806381f9d63dfc89e432 md5: 362bc94148039b77c6a42b1f7e7ef537 @@ -9111,6 +9472,7 @@ packages: - mpg123 >=1.32.9,<1.33.0a0 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 406978 timestamp: 1765181892661 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsodium-1.0.21-h80f16a2_3.conda @@ -9129,6 +9491,7 @@ packages: - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: blessing + purls: [] size: 939207 timestamp: 1764359457549 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.51.1-h10b116e_1.conda @@ -9139,6 +9502,7 @@ packages: - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: blessing + purls: [] size: 943924 timestamp: 1766319577347 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.52.0-h10b116e_0.conda @@ -9152,40 +9516,18 @@ packages: purls: [] size: 952296 timestamp: 1772818881550 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - sha256: a835400072fb638fb582ee9fc2271169da84cbcad664d28b852610201116027e - md5: 2cd50877f494b34383af22560ced8b04 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + sha256: da46b52f6815e9771f4e21e3332c423c88644e91ac96b0534e85158adc88a8b4 + md5: 99898219505ff142be5734dc6fa0d900 depends: - - icu >=78.3,<79.0a0 - libgcc >=14 - libzlib >=1.3.2,<2.0a0 license: blessing run_exports: weak: - - libsqlite >=3.53.3,<4.0a0 - size: 968420 - timestamp: 1782519054102 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_15.conda - sha256: f6347ce1d1a8a9ecfa16fc118594b0a5cab9194a8dcc7e79cd02a7497822d1d2 - md5: 2873f805cdabcf33b880b19077cf6180 - depends: - - libgcc 15.2.0 h8acb6b2_15 - constrains: - - libstdcxx-ng ==15.2.0=*_15 - license: GPL-3.0-only WITH GCC-exception-3.1 - size: 5540090 - timestamp: 1764836183565 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_16.conda - sha256: 4db11a903707068ae37aa6909511c68e9af6a2e97890d1b73b0a8d87cb74aba9 - md5: 52d9df8055af3f1665ba471cce77da48 - depends: - - libgcc 15.2.0 h8acb6b2_16 - constrains: - - libstdcxx-ng ==15.2.0=*_16 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 5541149 - timestamp: 1765256980783 + - libsqlite >=3.53.4,<4.0a0 + size: 963888 + timestamp: 1785016056926 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_18.conda sha256: 31fdb9ffafad106a213192d8319b9f810e05abca9c5436b60e507afb35a6bc40 md5: f56573d05e3b735cb03efeb64a15f388 @@ -9198,45 +9540,32 @@ packages: purls: [] size: 5541411 timestamp: 1771378162499 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - sha256: 1dadc45e599f510dd5f97141dddcdbb9844d9f1430c1f3a38075cf1c58f87b4e - md5: 543fbc8d71f2a0baf04cf88ce96cb8bb +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + sha256: 81ef9a10a0e01ffc7e03d429ed048410153411b2d8bbf95c334bdf3dcf175ab0 + md5: 0bfd287b881e05351a01c7ebf7bf8f1b depends: - - libgcc 15.2.0 h8acb6b2_19 + - libgcc 16.1.0 h205dda4_1 constrains: - - libstdcxx-ng ==15.2.0=*_19 + - libstdcxx-ng ==16.1.0=*_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] run_exports: {} - size: 5546559 - timestamp: 1778268777463 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_15.conda - sha256: 73d026540bd2ec75186bc82c164fbfa51cbe44c4c27ed64b57bf52b10f6f3d63 - md5: 7a99de7c14096347968d1fd574b46bb2 - depends: - - libstdcxx 15.2.0 hef695bb_15 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 26977 - timestamp: 1764836231696 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_16.conda - sha256: dd5c813ae5a4dac6fa946352674e0c21b1847994a717ef67bd6cc77bc15920be - md5: 20b7f96f58ccbe8931c3a20778fb3b32 - depends: - - libstdcxx 15.2.0 hef695bb_16 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - size: 27376 - timestamp: 1765257033344 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_18.conda - sha256: 035a31cde134e706e30029a837a31f729ad32b7c5bca023271dfe91a8ba6c896 - md5: 699d294376fe18d80b7ce7876c3a875d + size: 6255794 + timestamp: 1785374543663 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-16.1.0-hdbbeba8_1.conda + sha256: cb88eb500022e01f835209e771d455d2296e10a18a749f518c257dfcab7d46ba + md5: a728408241f9db99bad0d1642c908714 depends: - - libstdcxx 15.2.0 hef695bb_18 + - libstdcxx 16.1.0 hef695bb_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 27645 - timestamp: 1771378204663 + purls: [] + run_exports: + strong: + - libstdcxx + size: 28182 + timestamp: 1785374577436 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.10-hf9559e3_4.conda sha256: 95bb4c430e8ca666a4c67b7951f03fbee5a5258b1d29c2a26bf56c86fe32c010 md5: 96e731e9cf876fb2d8882093c0f24630 @@ -9244,6 +9573,7 @@ packages: - libcap >=2.77,<2.78.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 517911 timestamp: 1770738680829 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hf9559e3_0.conda @@ -9263,6 +9593,7 @@ packages: - libcap >=2.78,<2.79.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] run_exports: {} size: 515284 timestamp: 1780084773602 @@ -9280,6 +9611,7 @@ packages: - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 license: HPND + purls: [] size: 488407 timestamp: 1762022048105 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.10-hf9559e3_4.conda @@ -9289,6 +9621,7 @@ packages: - libcap >=2.77,<2.78.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 157130 timestamp: 1770738690431 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hf9559e3_0.conda @@ -9308,6 +9641,7 @@ packages: - libcap >=2.78,<2.79.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] run_exports: {} size: 156922 timestamp: 1780084778404 @@ -9319,6 +9653,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 94555 timestamp: 1757032278900 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liburing-2.12-hfefdfc9_0.conda @@ -9329,6 +9664,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 129619 timestamp: 1756126369793 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liburing-2.13-hfefdfc9_0.conda @@ -9339,6 +9675,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 134026 timestamp: 1765873930570 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liburing-2.14-hfefdfc9_0.conda @@ -9349,6 +9686,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 155011 timestamp: 1770567701524 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libusb-1.0.29-h06eaf92_0.conda @@ -9358,6 +9696,7 @@ packages: - libgcc >=13 - libudev1 >=257.4 license: LGPL-2.1-or-later + purls: [] size: 93129 timestamp: 1748856228398 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.41.2-h1022ec0_1.conda @@ -9366,6 +9705,7 @@ packages: depends: - libgcc >=14 license: BSD-3-Clause + purls: [] size: 43415 timestamp: 1764790752623 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.41.3-h1022ec0_0.conda @@ -9375,6 +9715,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 43453 timestamp: 1766271546875 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42-h1022ec0_0.conda @@ -9409,6 +9750,7 @@ packages: - libogg >=1.3.5,<1.4.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 289391 timestamp: 1753879417231 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libvpx-1.15.2-hfae3067_0.conda @@ -9419,6 +9761,7 @@ packages: - libstdcxx >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 1296382 timestamp: 1762012332100 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libvulkan-loader-1.4.328.1-h8b8848b_0.conda @@ -9433,6 +9776,7 @@ packages: - libvulkan-headers 1.4.328.1.* license: Apache-2.0 license_family: APACHE + purls: [] size: 214593 timestamp: 1759972148472 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libvulkan-loader-1.4.341.0-h8b8848b_0.conda @@ -9447,6 +9791,7 @@ packages: - libvulkan-headers 1.4.341.0.* license: Apache-2.0 license_family: APACHE + purls: [] size: 217655 timestamp: 1770077141862 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libwebp-base-1.6.0-ha2e29f5_0.conda @@ -9458,6 +9803,7 @@ packages: - libwebp 1.6.0 license: BSD-3-Clause license_family: BSD + purls: [] size: 359496 timestamp: 1752160685488 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcb-1.17.0-h262b8f6_0.conda @@ -9470,6 +9816,7 @@ packages: - xorg-libxdmcp license: MIT license_family: MIT + purls: [] size: 397493 timestamp: 1727280745441 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda @@ -9494,6 +9841,7 @@ packages: - xorg-libxau >=1.0.12,<2.0a0 license: MIT/X11 Derivative license_family: MIT + purls: [] size: 863646 timestamp: 1764794352540 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.1-h79dcc73_1.conda @@ -9509,6 +9857,7 @@ packages: - libxml2 2.15.1 license: MIT license_family: MIT + purls: [] size: 599721 timestamp: 1766327134458 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.1-h8591a01_0.conda @@ -9524,6 +9873,7 @@ packages: - libxml2 2.15.1 license: MIT license_family: MIT + purls: [] size: 597078 timestamp: 1761015734476 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.2-h79dcc73_0.conda @@ -9539,6 +9889,7 @@ packages: - libxml2 2.15.2 license: MIT license_family: MIT + purls: [] size: 598438 timestamp: 1772704671710 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.1-h788dabe_0.conda @@ -9553,6 +9904,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 47192 timestamp: 1761015739999 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.1-h825857f_1.conda @@ -9567,6 +9919,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 47725 timestamp: 1766327143205 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.2-h825857f_0.conda @@ -9581,6 +9934,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 47837 timestamp: 1772704681112 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h86ecc28_2.conda @@ -9592,6 +9946,7 @@ packages: - zlib 1.3.1 *_2 license: Zlib license_family: Other + purls: [] size: 66657 timestamp: 1727963199518 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda @@ -9607,6 +9962,18 @@ packages: - libzlib >=1.3.2,<2.0a0 size: 69833 timestamp: 1774072605429 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda + sha256: 76efa6cc9d7e6f5ee3bbca0939f64054af2bdfb3c3632531f8e633cf6c2ea41e + md5: bd534c2fbe56d8c2ea3b2d8f5e12bca8 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 70108 + timestamp: 1785276540870 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/make-4.4.1-h2a6d0cb_2.conda sha256: d243aea768e6fa360b7eda598340f43d2a41c9fc169d9f97f505410be68815f8 md5: 5983ffb12d09efc45c4a3b74cd890137 @@ -9640,6 +10007,7 @@ packages: - libstdcxx >=13 license: LGPL-2.1-only license_family: LGPL + purls: [] size: 558708 timestamp: 1730581372400 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/msgpack-python-1.1.2-py312h4f740d2_1.conda @@ -9694,6 +10062,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 7815328 timestamp: 1763351321550 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.4.0-py314haac167e_0.conda @@ -9712,6 +10082,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 8001251 timestamp: 1766373967611 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.4.2-py314haac167e_1.conda @@ -9730,6 +10102,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 8006259 timestamp: 1770098510476 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.4.3-py312h6615c27_0.conda @@ -9760,6 +10134,7 @@ packages: - libstdcxx >=13 license: BSD-2-Clause license_family: BSD + purls: [] size: 774512 timestamp: 1739400731652 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.0-h8e36d6e_0.conda @@ -9770,6 +10145,7 @@ packages: - libgcc >=14 license: Apache-2.0 license_family: Apache + purls: [] size: 3705625 timestamp: 1762841024958 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.1-h546c87b_1.conda @@ -9783,9 +10159,9 @@ packages: purls: [] size: 3692030 timestamp: 1769557678657 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda - sha256: da4a5df42614166b69c2f6d8602fc1425f7aaa699f77c3bafb5c7fe69b3d9fb7 - md5: fa6260b3e6eababf6ca85a7eb3336383 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + sha256: c89e748e8a008e8ca6f25e102362f33319db0c98cc29d98ddada92842f636327 + md5: 1600dfde78c5adba306f8571af62a323 depends: - ca-certificates - libgcc >=14 @@ -9794,8 +10170,8 @@ packages: run_exports: weak: - openssl >=3.6.3,<4.0a0 - size: 3704664 - timestamp: 1781069675555 + size: 3719270 + timestamp: 1785913554920 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pango-1.56.4-he55ef5b_0.conda sha256: dd36cd5b6bc1c2988291a6db9fa4eb8acade9b487f6f1da4eaa65a1eebb0a12d md5: a22cc88bf6059c9bcc158c94c9aab5b8 @@ -9813,6 +10189,7 @@ packages: - libpng >=1.6.49,<1.7.0a0 - libzlib >=1.3.1,<2.0a0 license: LGPL-2.1-or-later + purls: [] size: 468811 timestamp: 1751293869070 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pcre2-10.47-hf841c20_0.conda @@ -9824,6 +10201,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1166552 timestamp: 1763655534263 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pixman-0.46.4-h7ac5ae9_1.conda @@ -9835,6 +10213,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 357913 timestamp: 1754665583353 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py312hd41f8a7_0.conda @@ -9858,6 +10237,7 @@ packages: - libgcc >=13 license: MIT license_family: MIT + purls: [] size: 8342 timestamp: 1726803319942 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pugixml-1.15-h6ef32b0_0.conda @@ -9868,6 +10248,7 @@ packages: - libstdcxx >=13 license: MIT license_family: MIT + purls: [] size: 113424 timestamp: 1737355438448 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pulseaudio-client-17.0-hcf98165_3.conda @@ -9885,6 +10266,7 @@ packages: - pulseaudio 17.0 *_3 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 760306 timestamp: 1763148231117 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.12.13-h91f4b29_0_cpython.conda @@ -9936,6 +10318,7 @@ packages: - tzdata - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 37149339 timestamp: 1764757159033 python_site_packages_path: lib/python3.14/site-packages @@ -9962,6 +10345,7 @@ packages: - tzdata - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 37217543 timestamp: 1765020325291 python_site_packages_path: lib/python3.14/site-packages @@ -9988,13 +10372,14 @@ packages: - tzdata - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 37305578 timestamp: 1770674395875 python_site_packages_path: lib/python3.14/site-packages -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda - build_number: 100 - sha256: dd56fd95db3cb49a69fbe41df80afc8bd5214daa829bcd3930de80f0408ba5eb - md5: 416c74941d13d9f2b9e68b1a900f7f50 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda + build_number: 101 + sha256: b8135c10971f387402f42b8fe52cf983665e9af9a7b5c839ae082a0f71f6c0c4 + md5: 6ed1a6d56adc15f18919b6fc87660bd1 depends: - bzip2 >=1.0.8,<2.0a0 - ld_impl_linux-aarch64 >=2.36.1 @@ -10003,8 +10388,8 @@ packages: - libgcc >=14 - liblzma >=5.8.3,<6.0a0 - libmpdec >=4.0.0,<5.0a0 - - libsqlite >=3.53.2,<4.0a0 - - libuuid >=2.42.1,<3.0a0 + - libsqlite >=3.53.3,<4.0a0 + - libuuid >=2.42.2,<3.0a0 - libzlib >=1.3.2,<2.0a0 - ncurses >=6.6,<7.0a0 - openssl >=3.5.7,<4.0a0 @@ -10019,8 +10404,8 @@ packages: - python_abi 3.14.* *_cp314 noarch: - python - size: 34900936 - timestamp: 1781254861576 + size: 34850010 + timestamp: 1784909900639 python_site_packages_path: lib/python3.14/site-packages - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.3-py312ha4530ae_1.conda sha256: 0ba02720b470150a8c6261a86ea4db01dcf121e16a3e3978a84e965d3fe9c39a @@ -10079,6 +10464,7 @@ packages: - libudev1 >=257.13 license: Linux-OpenIB license_family: BSD + purls: [] run_exports: weak: - rdma-core >=63.0 @@ -10092,6 +10478,7 @@ packages: - ncurses >=6.5,<7.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 291806 timestamp: 1740380591358 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda @@ -10170,6 +10557,7 @@ packages: - libgl >=1.7.0,<2.0a0 - libegl >=1.7.0,<2.0a0 license: Zlib + purls: [] size: 597756 timestamp: 1757842928996 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/sdl3-3.2.28-h3d544e7_0.conda @@ -10195,6 +10583,7 @@ packages: - libunwind >=1.8.3,<1.9.0a0 - pulseaudio-client >=17.0,<17.1.0a0 license: Zlib + purls: [] size: 1929093 timestamp: 1764713313724 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/sdl3-3.2.30-h3d544e7_0.conda @@ -10220,6 +10609,7 @@ packages: - libgl >=1.7.0,<2.0a0 - xorg-libx11 >=1.8.12,<2.0a0 license: Zlib + purls: [] size: 1928569 timestamp: 1767236340915 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/sdl3-3.4.2-had2c13b_0.conda @@ -10248,6 +10638,7 @@ packages: - dbus >=1.16.2,<2.0a0 - xorg-libx11 >=1.8.13,<2.0a0 license: Zlib + purls: [] size: 2136476 timestamp: 1771668207211 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shaderc-2025.5-h8c88b8f_0.conda @@ -10260,6 +10651,7 @@ packages: - spirv-tools >=2025,<2026.0a0 license: Apache-2.0 license_family: Apache + purls: [] size: 115395 timestamp: 1764287938541 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shaderc-2025.5-hfeb5c2c_1.conda @@ -10272,6 +10664,7 @@ packages: - spirv-tools >=2026,<2027.0a0 license: Apache-2.0 license_family: Apache + purls: [] size: 115498 timestamp: 1770208786806 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/snappy-1.2.2-he774c54_1.conda @@ -10283,6 +10676,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 47096 timestamp: 1762948094646 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/spirv-tools-2025.4-hfefdfc9_0.conda @@ -10295,6 +10689,7 @@ packages: - spirv-headers >=1.4.328.0,<1.4.328.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 2511309 timestamp: 1759805874123 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/spirv-tools-2026.1-hfefdfc9_0.conda @@ -10307,6 +10702,7 @@ packages: - spirv-headers >=1.4.341.0,<1.4.341.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 2255599 timestamp: 1770089690097 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/sqlalchemy-2.0.49-py312h2fc9c67_0.conda @@ -10332,6 +10728,7 @@ packages: - libstdcxx >=14 license: BSD-2-Clause license_family: BSD + purls: [] size: 2106252 timestamp: 1756090698097 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/svt-av1-4.0.1-hfae3067_0.conda @@ -10342,6 +10739,7 @@ packages: - libstdcxx >=14 license: BSD-2-Clause license_family: BSD + purls: [] size: 2042800 timestamp: 1769668627820 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tbb-2022.3.0-h0eac15c_1.conda @@ -10353,6 +10751,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 144223 timestamp: 1762511489745 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tbb-2022.3.0-hfefdfc9_2.conda @@ -10364,6 +10763,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 144746 timestamp: 1767888618836 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda @@ -10389,6 +10789,7 @@ packages: - xorg-libx11 >=1.8.12,<2.0a0 license: TCL license_family: BSD + purls: [] size: 3333495 timestamp: 1763059192223 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda @@ -10419,9 +10820,9 @@ packages: - pkg:pypi/tornado?source=hash-mapping size: 859168 timestamp: 1774359394755 -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda - sha256: f17967c3ed7ad0b92ca97a7abfdf3e556d91649cbd74a1dd35962a333cfbed78 - md5: ef5ef192c6e6f74b6b1271b248336104 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda + sha256: 1c3f53ff574ca92562c83e29ab158d0e5790ed3dc0a70bc6c7a6e6108bc5c623 + md5: db4ed0e0968098dd8bdca55d62dc5dc5 depends: - libgcc >=14 - libstdcxx >=14 @@ -10429,8 +10830,8 @@ packages: - __glibc >=2.17 license: Apache-2.0 OR MIT run_exports: {} - size: 20306087 - timestamp: 1784166394558 + size: 17181969 + timestamp: 1785973409651 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/wayland-1.24.0-h4f8a99f_1.conda sha256: d94af8f287db764327ac7b48f6c0cd5c40da6ea2606afd34ac30671b7c85d8ee md5: f6966cb1f000c230359ae98c29e37d87 @@ -10441,6 +10842,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 331480 timestamp: 1761174368396 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/x264-1!164.3095-h4e544f5_2.tar.bz2 @@ -10450,6 +10852,7 @@ packages: - libgcc-ng >=12 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 1000661 timestamp: 1660324722559 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/x265-3.5-hdd96247_3.tar.bz2 @@ -10460,6 +10863,7 @@ packages: - libstdcxx-ng >=10.3.0 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 1018181 timestamp: 1646610147365 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xkeyboard-config-2.46-he30d5cf_0.conda @@ -10470,6 +10874,7 @@ packages: - xorg-libx11 >=1.8.12,<2.0a0 license: MIT license_family: MIT + purls: [] size: 396706 timestamp: 1759543850920 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xkeyboard-config-2.47-he30d5cf_0.conda @@ -10480,6 +10885,7 @@ packages: - xorg-libx11 >=1.8.13,<2.0a0 license: MIT license_family: MIT + purls: [] size: 399629 timestamp: 1772021320967 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libice-1.1.2-h86ecc28_0.conda @@ -10489,6 +10895,7 @@ packages: - libgcc >=13 license: MIT license_family: MIT + purls: [] size: 60433 timestamp: 1734229908988 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libsm-1.2.6-h0808dbd_0.conda @@ -10500,6 +10907,7 @@ packages: - xorg-libice >=1.1.2,<2.0a0 license: MIT license_family: MIT + purls: [] size: 28701 timestamp: 1741897678254 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libx11-1.8.12-hca56bd8_0.conda @@ -10510,6 +10918,7 @@ packages: - libxcb >=1.17.0,<2.0a0 license: MIT license_family: MIT + purls: [] size: 864850 timestamp: 1741901264068 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libx11-1.8.13-h63a1b12_0.conda @@ -10520,6 +10929,7 @@ packages: - libxcb >=1.17.0,<2.0a0 license: MIT license_family: MIT + purls: [] size: 869058 timestamp: 1770819244991 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxau-1.0.12-he30d5cf_1.conda @@ -10529,6 +10939,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 16317 timestamp: 1762977521691 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxcursor-1.2.3-h86ecc28_0.conda @@ -10541,6 +10952,7 @@ packages: - xorg-libxrender >=0.9.11,<0.10.0a0 license: MIT license_family: MIT + purls: [] size: 34596 timestamp: 1730908388714 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxdmcp-1.1.5-he30d5cf_1.conda @@ -10550,6 +10962,7 @@ packages: - libgcc >=14 license: MIT license_family: MIT + purls: [] size: 21039 timestamp: 1762979038025 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxext-1.3.6-h57736b2_0.conda @@ -10560,6 +10973,7 @@ packages: - xorg-libx11 >=1.8.9,<2.0a0 license: MIT license_family: MIT + purls: [] size: 50746 timestamp: 1727754268156 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxext-1.3.7-he30d5cf_0.conda @@ -10570,6 +10984,7 @@ packages: - xorg-libx11 >=1.8.12,<2.0a0 license: MIT license_family: MIT + purls: [] size: 52409 timestamp: 1769446753771 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxfixes-6.0.2-he30d5cf_0.conda @@ -10580,6 +10995,7 @@ packages: - xorg-libx11 >=1.8.12,<2.0a0 license: MIT license_family: MIT + purls: [] size: 20704 timestamp: 1759284028146 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxi-1.8.2-h57736b2_0.conda @@ -10592,6 +11008,7 @@ packages: - xorg-libxfixes >=6.0.1,<7.0a0 license: MIT license_family: MIT + purls: [] size: 48197 timestamp: 1727801059062 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxrandr-1.5.4-h86ecc28_0.conda @@ -10604,6 +11021,7 @@ packages: - xorg-libxrender >=0.9.11,<0.10.0a0 license: MIT license_family: MIT + purls: [] size: 30197 timestamp: 1727794957221 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxrandr-1.5.5-he30d5cf_0.conda @@ -10616,6 +11034,7 @@ packages: - xorg-libxrender >=0.9.12,<0.10.0a0 license: MIT license_family: MIT + purls: [] size: 31122 timestamp: 1769445286951 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxrender-0.9.12-h86ecc28_0.conda @@ -10626,6 +11045,7 @@ packages: - xorg-libx11 >=1.8.10,<2.0a0 license: MIT license_family: MIT + purls: [] size: 33649 timestamp: 1734229123157 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxscrnsaver-1.2.4-h86ecc28_0.conda @@ -10637,6 +11057,7 @@ packages: - xorg-libxext >=1.3.6,<2.0a0 license: MIT license_family: MIT + purls: [] size: 15720 timestamp: 1750007336692 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxtst-1.2.5-h57736b2_3.conda @@ -10649,6 +11070,7 @@ packages: - xorg-libxi >=1.7.10,<2.0a0 license: MIT license_family: MIT + purls: [] size: 33786 timestamp: 1727964907993 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/yaml-0.2.5-h80f16a2_3.conda @@ -10832,6 +11254,7 @@ packages: depends: - __win license: ISC + purls: [] size: 152827 timestamp: 1762967310929 - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.11.12-hbd8a1cb_0.conda @@ -10840,6 +11263,7 @@ packages: depends: - __unix license: ISC + purls: [] size: 152432 timestamp: 1762967197890 - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.1.4-h4c7d964_0.conda @@ -10848,6 +11272,7 @@ packages: depends: - __win license: ISC + purls: [] size: 147139 timestamp: 1767500904211 - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.1.4-hbd8a1cb_0.conda @@ -10856,6 +11281,7 @@ packages: depends: - __unix license: ISC + purls: [] size: 146519 timestamp: 1767500828366 - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda @@ -10876,24 +11302,24 @@ packages: purls: [] size: 147413 timestamp: 1772006283803 -- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda - sha256: 7f458e4a82514d7bebbfef23d92817794a16aaf1c748a15f04870d4fb49aeab2 - md5: b9696b2cf00dfeec138c70cee38ed192 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda + sha256: 95e8e74062a5fe5f870ac8c90302b6e89945165fdaed7810606e84ddee6aac12 + md5: e27d2ac27b096dc51fedfcf775a53f9b depends: - __win license: ISC run_exports: {} - size: 129352 - timestamp: 1781709016515 -- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - sha256: f8e3c730fa14ee3f170493779f06522c4acf89169f43db4f039727709b6419cf - md5: a9965dd99f683c5f444428f896635716 + size: 132136 + timestamp: 1784754918886 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + sha256: 0a0544cf95f64394fe4959286f5c71f5444ad58feb0602e53becb27448d24da6 + md5: 0f51e2391ade309db462a55611263e9c depends: - __unix license: ISC run_exports: {} - size: 128866 - timestamp: 1781708962055 + size: 131780 + timestamp: 1784754889428 - conda: https://conda.anaconda.org/conda-forge/noarch/cachecontrol-0.14.3-pyha770c72_0.conda sha256: ec791bb6f1ef504411f87b28946a7ae63ed1f3681cefc462cf1dfdaf0790b6a9 md5: 241ef6e3db47a143ac34c21bfba510f1 @@ -11007,6 +11433,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1150650 timestamp: 1746189825236 @@ -11016,17 +11443,18 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 1472271 timestamp: 1779895496841 -- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_0.conda - sha256: 51106d05567031d9b10a26bcaea95022c9ae91ce44758df5dec86d46985bef61 - md5: c7aab5efb8e8151a038f9eb271f23dcf +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_1.conda + sha256: fa44586fc308d0089fb5f014d5b53cbea19a2e83cd7bbd1e19c79140293be9a3 + md5: 199a317645eac1a18745d05dc551ab6e depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement run_exports: {} - size: 1475805 - timestamp: 1782773759292 + size: 1486700 + timestamp: 1785874560026 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-12.9.27-h579c4fd_0.conda sha256: b4efaee8fa95b9ec97a462dc343914a138ece704895e33caa52ac55968f7adfa md5: 71e4d87a72bf003bd05f05a502288b2a @@ -11034,6 +11462,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1149299 timestamp: 1746189919921 @@ -11044,24 +11473,26 @@ packages: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 1481900 timestamp: 1779895522474 -- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_0.conda - sha256: 2f9d85d0297b0c461518e5665351d73ffc5f7c9e2aa8b6e3e1cd9498bdd31cd0 - md5: 29bc81fe5927466cd27f2e1151e8502a +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_1.conda + sha256: 0b5f21da410f288503f4f9b97b0d4bbec670c25dbf2317b6a92703fbe1a8b91a + md5: 23397299679c728e710be12875f64857 depends: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement run_exports: {} - size: 1480995 - timestamp: 1782773779842 + size: 1479144 + timestamp: 1785874588629 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-12.9.27-h57928b3_0.conda sha256: 681eb1d9afd596e04329a82b04734c0e37c6ecb94b3380f3a378d61983e2a8cc md5: 8f897dca7111f3bb4ded97ba6947b186 depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1139649 timestamp: 1746189858434 @@ -11071,23 +11502,25 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 1462453 timestamp: 1779895589763 -- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_0.conda - sha256: cc1524d3d25991ba509aa36b43c9b30ac1cde43820a4b318dbdd729e0ff029fe - md5: 64ff59f43bc9a8838324c8527d4d509d +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_1.conda + sha256: 57729383a520a75b1373c6795cd412e76f3799105e3240b258d33fbcc2d598e5 + md5: 6c36b47ed939964651d102a179699d1d depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement run_exports: {} - size: 1467923 - timestamp: 1782773832153 + size: 1476948 + timestamp: 1785874646188 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.9.86-ha770c72_2.conda sha256: e6257534c4b4b6b8a1192f84191c34906ab9968c92680fa09f639e7846a87304 md5: 79d280de61e18010df5997daea4743df depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 94239 timestamp: 1753975242354 @@ -11097,6 +11530,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 116655 timestamp: 1779905079263 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda @@ -11115,6 +11549,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 94794 timestamp: 1753975199249 @@ -11125,6 +11560,7 @@ packages: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 116665 timestamp: 1779905122757 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda @@ -11143,6 +11579,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 95452 timestamp: 1753975640812 @@ -11152,6 +11589,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 117452 timestamp: 1779905164275 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-13.3.73-h57928b3_0.conda @@ -11172,6 +11610,7 @@ packages: - cuda-cudart_linux-64 - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -11186,6 +11625,7 @@ packages: - cuda-cudart_linux-64 - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=13.3.29,<14.0a0 @@ -11201,6 +11641,7 @@ packages: - cuda-cudart_linux-aarch64 - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -11216,6 +11657,7 @@ packages: - cuda-cudart_linux-aarch64 - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=13.3.29,<14.0a0 @@ -11230,6 +11672,7 @@ packages: - cuda-cudart_win-64 - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -11244,6 +11687,7 @@ packages: - cuda-cudart_win-64 - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1548117 timestamp: 1779898493787 @@ -11253,6 +11697,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1148889 timestamp: 1749218381225 @@ -11262,6 +11707,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1126340 timestamp: 1779898412056 @@ -11272,6 +11718,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1152498 timestamp: 1749218333554 @@ -11282,6 +11729,7 @@ packages: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1133087 timestamp: 1779898428591 @@ -11291,6 +11739,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 354611 timestamp: 1749218544740 @@ -11300,6 +11749,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 83026 timestamp: 1779898478182 @@ -11309,6 +11759,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 197249 timestamp: 1749218394213 @@ -11318,6 +11769,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 206064 timestamp: 1779898416941 @@ -11328,6 +11780,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 212993 timestamp: 1749218341193 @@ -11338,6 +11791,7 @@ packages: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 222441 timestamp: 1779898433566 @@ -11347,6 +11801,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23260 timestamp: 1749218569458 @@ -11356,6 +11811,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24659 timestamp: 1779898481919 @@ -11365,6 +11821,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27096 timestamp: 1753975261562 @@ -11374,6 +11831,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 28476 timestamp: 1779905085657 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.73-ha770c72_0.conda @@ -11392,6 +11850,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27218 timestamp: 1753975206503 @@ -11402,6 +11861,7 @@ packages: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 28720 timestamp: 1779905125664 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.73-h579c4fd_0.conda @@ -11420,6 +11880,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27284 timestamp: 1753975714790 @@ -11429,6 +11890,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 28779 timestamp: 1779905174253 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-13.3.73-h57928b3_0.conda @@ -11459,6 +11921,7 @@ packages: - cudatoolkit 12.9|12.9.* - __cuda >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 21578 timestamp: 1746134436166 @@ -11575,6 +12038,7 @@ packages: md5: 0c96522c6bdaed4b1566d11387caaf45 license: BSD-3-Clause license_family: BSD + purls: [] size: 397370 timestamp: 1566932522327 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 @@ -11582,6 +12046,7 @@ packages: md5: 34893075a5c9e55cdafac56607368fc6 license: OFL-1.1 license_family: Other + purls: [] size: 96530 timestamp: 1620479909603 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 @@ -11589,6 +12054,7 @@ packages: md5: 4d59c254e01d9cde7957100457e2d5fb license: OFL-1.1 license_family: Other + purls: [] size: 700814 timestamp: 1620479612257 - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda @@ -11596,6 +12062,7 @@ packages: md5: 49023d73832ef61042f6a237cb2687e7 license: LicenseRef-Ubuntu-Font-Licence-Version-1.0 license_family: Other + purls: [] size: 1620504 timestamp: 1727511233259 - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 @@ -11605,6 +12072,7 @@ packages: - fonts-conda-forge license: BSD-3-Clause license_family: BSD + purls: [] size: 3667 timestamp: 1566974674465 - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda @@ -11617,6 +12085,7 @@ packages: - font-ttf-source-code-pro license: BSD-3-Clause license_family: BSD + purls: [] size: 4059 timestamp: 1762351264405 - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda @@ -11699,6 +12168,8 @@ packages: - python license: Apache-2.0 license_family: APACHE + purls: + - pkg:pypi/importlib-metadata?source=hash-mapping size: 34641 timestamp: 1747934053147 - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda @@ -11992,6 +12463,7 @@ packages: - sysroot_linux-64 ==2.28 license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL + purls: [] run_exports: {} size: 1278712 timestamp: 1765578681495 @@ -12002,6 +12474,7 @@ packages: - sysroot_linux-aarch64 ==2.28 license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL + purls: [] run_exports: {} size: 1248134 timestamp: 1765578613607 @@ -12012,6 +12485,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 3094906 timestamp: 1765256682321 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_118.conda @@ -12021,18 +12495,19 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 3085932 timestamp: 1771378098166 -- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_119.conda - sha256: 38a557eba305468ac1f90ac85e50d8defd76141cb0b8a43b2fc1aca71dd5d5f2 - md5: 683fcb168e1df9a21fa80d5aa2d9330b +- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-16.1.0-h59071f9_101.conda + sha256: b314251d957b16c71ec241119ac09b9530c5c4ce140026ec98d297f55d6c5e08 + md5: 19b0151ecb1d122f706ebd2f82f9a017 depends: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL run_exports: {} - size: 3095909 - timestamp: 1778268932148 + size: 3096495 + timestamp: 1785375361053 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_116.conda sha256: 594e4f22a4b6aae1bca5e22ea3a075c070642ca4c27c53e0c0973926ca711e09 md5: 8ba6e9b5866b6a5429ca5d9fa12bc964 @@ -12040,6 +12515,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 2343262 timestamp: 1765256811670 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_118.conda @@ -12049,18 +12525,19 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 2364690 timestamp: 1771378032404 -- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda - sha256: fe600a63a39281e6994e27fe79360cd6bd8e576c3ce1af32ce8673b011f46c21 - md5: 18ad0f0b94071d91fa962a1bf3983a78 +- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-16.1.0-hd673532_101.conda + sha256: 885f0d8a47f7ea50d7b33d07a240f2301935602b9d2a39a35b5018b13e934100 + md5: 00cdfad75c8331e103f830fb17184da1 depends: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL run_exports: {} - size: 2353893 - timestamp: 1778268665954 + size: 2357226 + timestamp: 1785374433650 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_win-64-15.2.0-hbb59886_116.conda sha256: ffffa7c4e12ea0bb70d188eb003809c0579be974c721f0b53345e4e466857fa8 md5: 83cd21fa27411b91a3ec02ceb9f4d0ca @@ -12068,6 +12545,7 @@ packages: - m2-conda-epoch license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 2420086 timestamp: 1765260357692 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_win-64-15.2.0-hbb59886_118.conda @@ -12077,6 +12555,7 @@ packages: - m2-conda-epoch license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 2422242 timestamp: 1771382108271 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.2.0-hd446a21_116.conda @@ -12086,6 +12565,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 20763949 timestamp: 1765256724565 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.2.0-hd446a21_118.conda @@ -12095,18 +12575,19 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 20669511 timestamp: 1771378139786 -- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.2.0-hd446a21_119.conda - sha256: a2385f3611d5cd25378f9cf2367183320731709c067ddd08d43330d3170f15b8 - md5: bcfe7eae40158c3e355d2f9d3ed41230 +- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-16.1.0-h41cdd0d_101.conda + sha256: c1521172f2fdf5510d79b621ea835064209fe3131518e0d8b2b43362a75e7b4c + md5: 8593636203272a748b63d56cbd674753 depends: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL run_exports: {} - size: 20765069 - timestamp: 1778268963689 + size: 22519609 + timestamp: 1785375386152 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_116.conda sha256: 06be0d20cb3784e1d625f316f26962085dd14f74e166bd668ee9c089b5fa3efa md5: 48cfd02ec4f1308109e5daaccb99aa30 @@ -12114,6 +12595,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 17639950 timestamp: 1765256847600 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_118.conda @@ -12123,18 +12605,19 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 17628403 timestamp: 1771378058765 -- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda - sha256: 6f7ceee16070781b7d642a37a35ffdf09c66796d3df105c919526210ce220443 - md5: 61da34d67f58dd4cf16683f6cdcb06c8 +- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-16.1.0-h2445e1f_101.conda + sha256: 926d2c2dedfca7334804d5c8a0727a3746ef580be8763f51ccc2ece24c7be56c + md5: d2cd8c4b92b4e6dbcb2616d855107aca depends: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL run_exports: {} - size: 17627362 - timestamp: 1778268687968 + size: 19792513 + timestamp: 1785374457502 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_win-64-15.2.0-h0a72980_116.conda sha256: 40fce07ecab2b8d4777021e22fbae2f8ab39b5d1713ae3999efae225cd19c5ba md5: 53a797061ae48ff2bd1956c7abc20776 @@ -12142,6 +12625,7 @@ packages: - m2-conda-epoch license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 12310259 timestamp: 1765260383723 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_win-64-15.2.0-h0a72980_118.conda @@ -12151,6 +12635,7 @@ packages: - m2-conda-epoch license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 11729036 timestamp: 1771382135681 - conda: https://conda.anaconda.org/conda-forge/noarch/m2w64-sysroot_win-64-12.0.0.r4.gg4f2fc60ca-hd8ed1ab_10.conda @@ -12163,6 +12648,7 @@ packages: - mingw-w64-ucrt-x86_64-windows-default-manifest - mingw-w64-ucrt-x86_64-winpthreads-git 12.0.0.r4.gg4f2fc60ca hd8ed1ab_10 - ucrt + purls: [] size: 8421 timestamp: 1759768559974 - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.0.0-pyhd8ed1ab_0.conda @@ -12221,6 +12707,7 @@ packages: constrains: - mingw-w64-ucrt-x86_64-winpthreads-git 12.0.0.r4.gg4f2fc60ca.* license: ZPL-2.1 + purls: [] size: 5663635 timestamp: 1759768458961 - conda: https://conda.anaconda.org/conda-forge/noarch/mingw-w64-ucrt-x86_64-headers-git-12.0.0.r4.gg4f2fc60ca-hd8ed1ab_10.conda @@ -12232,6 +12719,7 @@ packages: - mingw-w64-ucrt-x86_64-crt-git 12.0.0.r4.gg4f2fc60ca.* - mingw-w64-ucrt-x86_64-winpthreads-git 12.0.0.r4.gg4f2fc60ca.* license: ZPL-2.1 AND LGPL-2.1-or-later + purls: [] size: 7089846 timestamp: 1759768412123 - conda: https://conda.anaconda.org/conda-forge/noarch/mingw-w64-ucrt-x86_64-windows-default-manifest-6.4-he206cdd_7.conda @@ -12242,6 +12730,7 @@ packages: constrains: - m2w64-sysroot_win-64 >=12.0.0.r0 license: FSFAP + purls: [] size: 7412 timestamp: 1717486007140 - conda: https://conda.anaconda.org/conda-forge/noarch/mingw-w64-ucrt-x86_64-winpthreads-git-12.0.0.r4.gg4f2fc60ca-hd8ed1ab_10.conda @@ -12253,6 +12742,7 @@ packages: constrains: - mingw-w64-ucrt-x86_64-crt-git 12.0.0.r4.gg4f2fc60ca.* license: MIT AND BSD-3-Clause-Clear + purls: [] size: 123916 timestamp: 1759768539535 - conda: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.1-pyhcf101f3_0.conda @@ -12392,6 +12882,8 @@ packages: - python license: Apache-2.0 license_family: APACHE + purls: + - pkg:pypi/packaging?source=hash-mapping size: 62477 timestamp: 1745345660407 - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.0-pyhcf101f3_0.conda @@ -12403,20 +12895,19 @@ packages: license: Apache-2.0 license_family: APACHE purls: - - pkg:pypi/packaging?source=compressed-mapping + - pkg:pypi/packaging?source=hash-mapping size: 72010 timestamp: 1769093650580 -- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 - md5: 4c06a92e74452cfa53623a81592e8934 +- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + sha256: c432626b16768b8dab228bfb706f7060c2d462a21c516d240f68f2f902b5a044 + md5: 936687ed80f295a1f5dbcf8bd34c252c depends: - - python >=3.8 + - python >=3.9 - python license: Apache-2.0 - license_family: APACHE run_exports: {} - size: 91574 - timestamp: 1777103621679 + size: 116363 + timestamp: 1785888127370 - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.6-pyhcf101f3_0.conda sha256: 42b2d77ccea60752f3aa929a6413a7835aaacdbbde679f2f5870a744fa836b94 md5: 97c1ce2fffa1209e7afb432810ec6e12 @@ -12519,6 +13010,8 @@ packages: - python >=3.9 license: MIT license_family: MIT + purls: + - pkg:pypi/py-cpuinfo?source=hash-mapping size: 25766 timestamp: 1733236452235 - conda: https://conda.anaconda.org/conda-forge/noarch/pydata-sphinx-theme-0.17.0-pyhcf101f3_0.conda @@ -12549,6 +13042,8 @@ packages: - python >=3.10 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/pyglet?source=hash-mapping size: 724353 timestamp: 1762495207513 - conda: https://conda.anaconda.org/conda-forge/noarch/pyglet-2.1.13-pyhd8ed1ab_0.conda @@ -12560,6 +13055,8 @@ packages: - python >=3.10 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/pyglet?source=hash-mapping size: 725938 timestamp: 1770169149613 - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda @@ -12569,6 +13066,8 @@ packages: - python >=3.9 license: BSD-2-Clause license_family: BSD + purls: + - pkg:pypi/pygments?source=hash-mapping size: 889287 timestamp: 1750615908735 - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda @@ -12637,6 +13136,8 @@ packages: - python >=3.10 license: BSD-2-Clause license_family: BSD + purls: + - pkg:pypi/pytest-benchmark?source=hash-mapping size: 43976 timestamp: 1762716480208 - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-randomly-3.15.0-pyhd8ed1ab_0.conda @@ -12648,6 +13149,8 @@ packages: - python >=3.6 license: MIT license_family: MIT + purls: + - pkg:pypi/pytest-randomly?source=hash-mapping size: 14133 timestamp: 1692131735622 - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-repeat-0.9.4-pyhd8ed1ab_0.conda @@ -12658,6 +13161,8 @@ packages: - python >=3.9 license: MPL-2.0 license_family: MOZILLA + purls: + - pkg:pypi/pytest-repeat?source=hash-mapping size: 10537 timestamp: 1744061283541 - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda @@ -12714,6 +13219,7 @@ packages: - python 3.14.* *_cp314 license: BSD-3-Clause license_family: BSD + purls: [] run_exports: {} size: 6989 timestamp: 1752805904792 @@ -12770,6 +13276,8 @@ packages: - python >=3.9 license: MIT license_family: MIT + purls: + - pkg:pypi/setuptools?source=hash-mapping size: 748788 timestamp: 1748804951958 - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda @@ -12793,9 +13301,9 @@ packages: run_exports: {} size: 642081 timestamp: 1783619174976 -- conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda - sha256: 8272686bacba85b683bf4ad1fedde16203b7610276074e22593a275b0ce3c017 - md5: 224418e442ea786882979fbd2b36061f +- conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + sha256: 8eb9daf6fc70111abf73f848c6d32d2769aa1fba550f793b865076fd4e33fb3a + md5: eefa3bc61c9224107d3a9afeb37552a9 depends: - python >=3.10 - vcs_versioning >=2.0.0.dev0 @@ -12807,8 +13315,8 @@ packages: license: MIT license_family: MIT run_exports: {} - size: 28577 - timestamp: 1782401906421 + size: 29407 + timestamp: 1784653562396 - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda sha256: 458227f759d5e3fcec5d9b7acce54e10c9e1f4f4b7ec978f3bfd54ce4ee9853d md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -13058,6 +13566,7 @@ packages: - tzdata license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL + purls: [] run_exports: strong: - __glibc >=2.28,<3.0.a0 @@ -13072,6 +13581,7 @@ packages: - tzdata license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL + purls: [] run_exports: strong: - __glibc >=2.28,<3.0.a0 @@ -13097,6 +13607,8 @@ packages: - python license: MIT license_family: MIT + purls: + - pkg:pypi/tomli?source=hash-mapping size: 20973 timestamp: 1760014679845 - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.0-pyhcf101f3_0.conda @@ -13107,6 +13619,8 @@ packages: - python license: MIT license_family: MIT + purls: + - pkg:pypi/tomli?source=hash-mapping size: 21453 timestamp: 1768146676791 - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda @@ -13183,6 +13697,7 @@ packages: sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 md5: 4222072737ccff51314b5ece9c7d6f5a license: LicenseRef-Public-Domain + purls: [] size: 122968 timestamp: 1742727099393 - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda @@ -13214,20 +13729,20 @@ packages: - pkg:pypi/urllib3?source=hash-mapping size: 103172 timestamp: 1767817860341 -- conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - sha256: 5728b15adf4e2877e510996e0d617d1531ccd8e55ca59358f60d3a10aaead5fa - md5: efbdc1f76721fb4ae7a1dbb5fff72562 +- conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + sha256: 179dd4ed561926e5ab95934009bb4359487264de149b5274e43e9e094900dfe4 + md5: 3a8fb54b1dc8fbfdeb51083a1143edd1 depends: - python >=3.10 - - packaging >=20 + - packaging >=26.2 - tomli >=1 - typing_extensions >=4.1 - python license: MIT license_family: MIT run_exports: {} - size: 83180 - timestamp: 1782748145197 + size: 83586 + timestamp: 1785306846938 - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda sha256: b72270395326dc56de9bd6ca82f63791b3c8c9e2b98e25242a9869a4ca821895 md5: f622897afff347b715d046178ad745a5 @@ -13243,6 +13758,7 @@ packages: md5: 7da1571f560d4ba3343f7f4c48a79c76 license: MIT license_family: MIT + purls: [] size: 140476 timestamp: 1765821981856 - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.6.0-pyhd8ed1ab_0.conda @@ -13329,6 +13845,7 @@ packages: - msys2-conda-epoch <0.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 49468 timestamp: 1718213032772 - conda: https://conda.anaconda.org/conda-forge/win-64/aom-3.9.1-he0c23c2_0.conda @@ -13340,6 +13857,7 @@ packages: - vc14_runtime >=14.29.30139 license: BSD-2-Clause license_family: BSD + purls: [] size: 1958151 timestamp: 1718551737234 - conda: https://conda.anaconda.org/conda-forge/win-64/backports.zstd-1.3.0-py312h06d0912_0.conda @@ -13366,6 +13884,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 5997864 timestamp: 1764007778611 - conda: https://conda.anaconda.org/conda-forge/win-64/binutils_impl_win-64-2.45-default_ha84baeb_105.conda @@ -13377,6 +13896,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 6096221 timestamp: 1766513640880 - conda: https://conda.anaconda.org/conda-forge/win-64/binutils_impl_win-64-2.45.1-default_ha84baeb_101.conda @@ -13388,6 +13908,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 5830940 timestamp: 1770267725685 - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.2.0-py312hc6d9e41_1.conda @@ -13407,6 +13928,20 @@ packages: - pkg:pypi/brotli?source=hash-mapping size: 335482 timestamp: 1764018063640 +- conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda + sha256: 04767466ee9227c9c57ab2c6503e0149177d34111c7418d2f420297acb1eb229 + md5: c3301c058362f340100d91cd8be0393f + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: bzip2-1.0.6 + license_family: BSD + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 55919 + timestamp: 1785906343696 - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda sha256: d882712855624641f48aa9dc3f5feea2ed6b4e6004585d3616386a18186fe692 md5: 1077e9333c41ff0be8edd1a5ec0ddace @@ -13416,6 +13951,7 @@ packages: - vc14_runtime >=14.44.35208 license: bzip2-1.0.6 license_family: BSD + purls: [] size: 55977 timestamp: 1757437738856 - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda @@ -13451,6 +13987,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LGPL-2.1-only or MPL-1.1 + purls: [] size: 1537783 timestamp: 1766416059188 - conda: https://conda.anaconda.org/conda-forge/win-64/cairo-1.18.4-h5782bbf_0.conda @@ -13470,6 +14007,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LGPL-2.1-only or MPL-1.1 + purls: [] size: 1524254 timestamp: 1741555212198 - conda: https://conda.anaconda.org/conda-forge/win-64/conda-gcc-specs-15.2.0-hd546029_16.conda @@ -13479,6 +14017,7 @@ packages: - gcc_impl_win-64 >=15.2.0,<15.2.1.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 54364 timestamp: 1765260662854 - conda: https://conda.anaconda.org/conda-forge/win-64/conda-gcc-specs-15.2.0-hd546029_18.conda @@ -13488,6 +14027,7 @@ packages: - gcc_impl_win-64 >=15.2.0,<15.2.1.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 54725 timestamp: 1771382417485 - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-13.2.0-py312hc128f0a_0.conda @@ -13522,6 +14062,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 170799 timestamp: 1749218946117 @@ -13535,6 +14076,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 215494 timestamp: 1779898489923 @@ -13550,6 +14092,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -13567,6 +14110,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24489 timestamp: 1779898504358 @@ -13580,6 +14124,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23249 timestamp: 1749218998822 @@ -13593,6 +14138,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24488 timestamp: 1779898500699 @@ -13605,6 +14151,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 58467504 timestamp: 1760723834711 @@ -13659,6 +14206,7 @@ packages: - cuda-nvvm-impl 12.9.86.* - cuda-nvvm-tools 12.9.86.* license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 26007 timestamp: 1771619504675 @@ -13670,6 +14218,7 @@ packages: - cuda-nvvm-impl 13.3.33.* - cuda-nvvm-tools 13.3.33.* license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 26223 timestamp: 1779909907942 - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-13.3.73-h719f0c7_0.conda @@ -13692,6 +14241,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 31168 timestamp: 1753975780038 @@ -13728,6 +14278,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 40286977 timestamp: 1753975898550 @@ -13740,6 +14291,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 45453672 timestamp: 1779905194696 - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-13.3.73-h2466b09_0.conda @@ -13761,6 +14313,7 @@ packages: - cuda-cudart-dev - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24150 timestamp: 1761098813665 @@ -13771,6 +14324,7 @@ packages: - cuda-cudart-dev - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 25690 timestamp: 1779913686281 @@ -13785,6 +14339,8 @@ packages: - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: APACHE + purls: + - pkg:pypi/cython?source=hash-mapping run_exports: {} size: 3338147 timestamp: 1782821777709 @@ -13804,6 +14360,20 @@ packages: run_exports: {} size: 3316549 timestamp: 1785016176418 +- conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda + sha256: a061170102d6f1a0b64ed3be712ac653fd9c9e8b6bed6205f398dbf319dcc3c8 + md5: 8ecd457018d6f302da0945cd2169167d + depends: + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: Apache-2.0 + license_family: APACHE + run_exports: {} + size: 3343814 + timestamp: 1785016211855 - conda: https://conda.anaconda.org/conda-forge/win-64/dav1d-1.2.1-hcfcfb64_0.conda sha256: 2aa2083c9c186da7d6f975ccfbef654ed54fff27f4bc321dbcd12cee932ec2c4 md5: ed2c27bda330e3f0ab41577cf8b9b585 @@ -13813,6 +14383,7 @@ packages: - vc14_runtime >=14.29.30139 license: BSD-2-Clause license_family: BSD + purls: [] size: 618643 timestamp: 1685696352968 - conda: https://conda.anaconda.org/conda-forge/win-64/debugpy-1.8.20-py312ha1a9051_0.conda @@ -13867,6 +14438,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 10420698 timestamp: 1765873656019 - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.0.1-gpl_h74fd8f1_908.conda @@ -13906,6 +14478,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 10416746 timestamp: 1766461370784 - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.0.1-gpl_hb2d76f6_914.conda @@ -13947,6 +14520,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 10417843 timestamp: 1773010275486 - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.15.0-h765892d_1.conda @@ -13962,6 +14536,7 @@ packages: - vc14_runtime >=14.29.30139 license: MIT license_family: MIT + purls: [] size: 192355 timestamp: 1730284147944 - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.17.1-hd47e2ca_0.conda @@ -13978,6 +14553,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 195332 timestamp: 1771382820659 - conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.1-h57928b3_0.conda @@ -13987,6 +14563,7 @@ packages: - libfreetype 2.14.1 h57928b3_0 - libfreetype6 2.14.1 hdbac1cb_0 license: GPL-2.0-only OR FTL + purls: [] size: 184553 timestamp: 1757946164012 - conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.2-h57928b3_0.conda @@ -13996,6 +14573,7 @@ packages: - libfreetype 2.14.2 h57928b3_0 - libfreetype6 2.14.2 hdbac1cb_0 license: GPL-2.0-only OR FTL + purls: [] size: 185633 timestamp: 1772756186241 - conda: https://conda.anaconda.org/conda-forge/win-64/fribidi-1.0.16-hfd05255_0.conda @@ -14006,6 +14584,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LGPL-2.1-or-later + purls: [] size: 64394 timestamp: 1757438741305 - conda: https://conda.anaconda.org/conda-forge/win-64/gcc-15.2.0-hd556455_16.conda @@ -14016,6 +14595,7 @@ packages: - gcc_impl_win-64 15.2.0 h79c4613_16 license: BSD-3-Clause license_family: BSD + purls: [] size: 1202509 timestamp: 1765260844098 - conda: https://conda.anaconda.org/conda-forge/win-64/gcc-15.2.0-hd556455_18.conda @@ -14026,6 +14606,7 @@ packages: - gcc_impl_win-64 15.2.0 ha526d7c_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 1198343 timestamp: 1771382604468 - conda: https://conda.anaconda.org/conda-forge/win-64/gcc_impl_win-64-15.2.0-h79c4613_16.conda @@ -14041,6 +14622,7 @@ packages: - m2w64-sysroot_win-64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 62325084 timestamp: 1765260533999 - conda: https://conda.anaconda.org/conda-forge/win-64/gcc_impl_win-64-15.2.0-ha526d7c_18.conda @@ -14056,6 +14638,7 @@ packages: - m2w64-sysroot_win-64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 62510234 timestamp: 1771382289787 - conda: https://conda.anaconda.org/conda-forge/win-64/gdk-pixbuf-2.44.4-h1f5b9c4_0.conda @@ -14073,6 +14656,7 @@ packages: - vc14_runtime >=14.44.35208 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 573466 timestamp: 1761082560321 - conda: https://conda.anaconda.org/conda-forge/win-64/gdk-pixbuf-2.44.5-h1f5b9c4_1.conda @@ -14090,6 +14674,7 @@ packages: - vc14_runtime >=14.44.35208 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 574950 timestamp: 1771530717329 - conda: https://conda.anaconda.org/conda-forge/win-64/glslang-16.1.0-h5b34520_0.conda @@ -14102,6 +14687,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD + purls: [] size: 6241332 timestamp: 1764720816129 - conda: https://conda.anaconda.org/conda-forge/win-64/glslang-16.2.0-h294ba9c_1.conda @@ -14114,6 +14700,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD + purls: [] size: 4929181 timestamp: 1770195251565 - conda: https://conda.anaconda.org/conda-forge/win-64/graphite2-1.3.14-hac47afa_2.conda @@ -14125,6 +14712,7 @@ packages: - vc14_runtime >=14.44.35208 license: LGPL-2.0-or-later license_family: LGPL + purls: [] size: 96336 timestamp: 1755102441729 - conda: https://conda.anaconda.org/conda-forge/win-64/greenlet-3.3.2-py312ha1a9051_0.conda @@ -14150,6 +14738,7 @@ packages: - gxx_impl_win-64 15.2.0 h22fd5bf_16 license: BSD-3-Clause license_family: BSD + purls: [] size: 823880 timestamp: 1765260877461 - conda: https://conda.anaconda.org/conda-forge/win-64/gxx-15.2.0-hf1b5d6d_18.conda @@ -14160,6 +14749,7 @@ packages: - gxx_impl_win-64 15.2.0 h22fd5bf_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 824078 timestamp: 1771382638258 - conda: https://conda.anaconda.org/conda-forge/win-64/gxx_impl_win-64-15.2.0-h22fd5bf_16.conda @@ -14172,6 +14762,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 14533037 timestamp: 1765260794852 - conda: https://conda.anaconda.org/conda-forge/win-64/gxx_impl_win-64-15.2.0-h22fd5bf_18.conda @@ -14184,6 +14775,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 14533744 timestamp: 1771382555150 - conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-12.2.0-h5f2951f_0.conda @@ -14203,6 +14795,7 @@ packages: - vc14_runtime >=14.29.30139 license: MIT license_family: MIT + purls: [] size: 1138900 timestamp: 1762373626704 - conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-12.3.0-h5a1b470_0.conda @@ -14222,6 +14815,7 @@ packages: - vc14_runtime >=14.29.30139 license: MIT license_family: MIT + purls: [] size: 1143524 timestamp: 1766937684751 - conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-13.1.0-h5a1b470_0.conda @@ -14241,6 +14835,7 @@ packages: - vc14_runtime >=14.29.30139 license: MIT license_family: MIT + purls: [] size: 1285640 timestamp: 1773217788574 - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda @@ -14252,6 +14847,7 @@ packages: - vc14_runtime >=14.29.30139 license: MIT license_family: MIT + purls: [] size: 14544252 timestamp: 1720853966338 - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.1-h637d24d_0.conda @@ -14263,6 +14859,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 13849749 timestamp: 1766299627069 - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.2-h637d24d_0.conda @@ -14274,6 +14871,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 13222158 timestamp: 1767970128854 - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h0ea6238_0.conda @@ -14298,6 +14896,7 @@ packages: - vs2015_runtime >=14.29.30139 license: LGPL-2.0-only license_family: LGPL + purls: [] size: 570583 timestamp: 1664996824680 - conda: https://conda.anaconda.org/conda-forge/win-64/ld_impl_win-64-2.45-default_hfd38196_104.conda @@ -14309,6 +14908,7 @@ packages: - binutils_impl_win-64 2.45 license: GPL-3.0-only license_family: GPL + purls: [] size: 876777 timestamp: 1764007762541 - conda: https://conda.anaconda.org/conda-forge/win-64/ld_impl_win-64-2.45-default_hfd38196_105.conda @@ -14320,6 +14920,7 @@ packages: - binutils_impl_win-64 2.45 license: GPL-3.0-only license_family: GPL + purls: [] size: 876611 timestamp: 1766513627408 - conda: https://conda.anaconda.org/conda-forge/win-64/ld_impl_win-64-2.45.1-default_hfd38196_101.conda @@ -14331,6 +14932,7 @@ packages: - binutils_impl_win-64 2.45.1 license: GPL-3.0-only license_family: GPL + purls: [] size: 876736 timestamp: 1770267709635 - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.0.0-h6470a55_1.conda @@ -14342,6 +14944,7 @@ packages: - vc14_runtime >=14.29.30139 license: Apache-2.0 license_family: Apache + purls: [] size: 164701 timestamp: 1745264384716 - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda @@ -14353,6 +14956,7 @@ packages: - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: Apache + purls: [] size: 172395 timestamp: 1773113455582 - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-5_hf2e6a31_mkl.conda @@ -14368,6 +14972,7 @@ packages: - liblapacke 3.11.0 5*_mkl license: BSD-3-Clause license_family: BSD + purls: [] size: 67438 timestamp: 1765819100043 - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-6_hf2e6a31_mkl.conda @@ -14395,6 +15000,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 82042 timestamp: 1764017799966 - conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlidec-1.2.0-hfd05255_1.conda @@ -14407,6 +15013,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 34449 timestamp: 1764017851337 - conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlienc-1.2.0-hfd05255_1.conda @@ -14419,6 +15026,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 252903 timestamp: 1764017901735 - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-5_h2a3cdd5_mkl.conda @@ -14433,6 +15041,7 @@ packages: - blas 2.305 mkl license: BSD-3-Clause license_family: BSD + purls: [] size: 68079 timestamp: 1765819124349 - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-6_h2a3cdd5_mkl.conda @@ -14459,6 +15068,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 156818 timestamp: 1761979842440 - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.3-hac47afa_0.conda @@ -14472,6 +15082,7 @@ packages: - expat 2.7.3.* license: MIT license_family: MIT + purls: [] size: 70137 timestamp: 1763550049107 - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.4-hac47afa_0.conda @@ -14485,6 +15096,7 @@ packages: - expat 2.7.4.* license: MIT license_family: MIT + purls: [] size: 70323 timestamp: 1771259521393 - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.5-hac47afa_0.conda @@ -14539,6 +15151,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 44866 timestamp: 1760295760649 - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.1-h57928b3_0.conda @@ -14547,6 +15160,7 @@ packages: depends: - libfreetype6 >=2.14.1 license: GPL-2.0-only OR FTL + purls: [] size: 8109 timestamp: 1757946135015 - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.2-h57928b3_0.conda @@ -14555,6 +15169,7 @@ packages: depends: - libfreetype6 >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 8404 timestamp: 1772756167212 - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.1-hdbac1cb_0.conda @@ -14569,6 +15184,7 @@ packages: constrains: - freetype >=2.14.1 license: GPL-2.0-only OR FTL + purls: [] size: 340264 timestamp: 1757946133889 - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.2-hdbac1cb_0.conda @@ -14583,6 +15199,7 @@ packages: constrains: - freetype >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 340155 timestamp: 1772756166648 - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_16.conda @@ -14597,6 +15214,7 @@ packages: - msys2-conda-epoch <0.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 819696 timestamp: 1765260437409 - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_18.conda @@ -14629,6 +15247,7 @@ packages: constrains: - glib 2.86.3 *_0 license: LGPL-2.1-or-later + purls: [] size: 3818991 timestamp: 1765222145992 - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.4-h0c9aed9_1.conda @@ -14646,6 +15265,7 @@ packages: constrains: - glib 2.86.4 *_1 license: LGPL-2.1-or-later + purls: [] size: 4095369 timestamp: 1771863229701 - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_16.conda @@ -14657,6 +15277,7 @@ packages: - msys2-conda-epoch <0.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 663567 timestamp: 1765260367147 - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_18.conda @@ -14683,6 +15304,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD + purls: [] size: 2412642 timestamp: 1765090345611 - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.2-default_h4379cf1_1000.conda @@ -14708,6 +15330,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: Apache-2.0 OR BSD-3-Clause + purls: [] size: 536186 timestamp: 1758894243956 - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda @@ -14727,6 +15350,7 @@ packages: depends: - libiconv >=1.17,<2.0a0 license: LGPL-2.1-or-later + purls: [] size: 95568 timestamp: 1723629479451 - conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.1.2-hfd05255_0.conda @@ -14739,6 +15363,7 @@ packages: constrains: - jpeg <0.0.0a license: IJG AND BSD-3-Clause AND Zlib + purls: [] size: 841783 timestamp: 1762094814336 - conda: https://conda.anaconda.org/conda-forge/win-64/libjxl-0.11.2-hf3f85d1_0.conda @@ -14753,6 +15378,7 @@ packages: - libhwy >=1.3.0,<1.4.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1317916 timestamp: 1770801992810 - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-5_hf9ab0e9_mkl.conda @@ -14767,6 +15393,7 @@ packages: - liblapacke 3.11.0 5*_mkl license: BSD-3-Clause license_family: BSD + purls: [] size: 80225 timestamp: 1765819148014 - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-6_hf9ab0e9_mkl.conda @@ -14794,6 +15421,7 @@ packages: constrains: - xz 5.8.1.* license: 0BSD + purls: [] size: 104935 timestamp: 1749230611612 - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.2-hfd05255_0.conda @@ -14833,6 +15461,7 @@ packages: - vc14_runtime >=14.29.30139 license: BSD-2-Clause license_family: BSD + purls: [] size: 88657 timestamp: 1723861474602 - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda @@ -14844,6 +15473,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-2-Clause license_family: BSD + purls: [] run_exports: {} size: 89411 timestamp: 1769482314283 @@ -14856,6 +15486,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 345320 timestamp: 1761099100395 - conda: https://conda.anaconda.org/conda-forge/win-64/libnvfatbin-12.9.82-hac47afa_2.conda @@ -14867,6 +15498,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 345191 timestamp: 1782920356823 @@ -14879,6 +15511,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 361081 timestamp: 1779897659188 - conda: https://conda.anaconda.org/conda-forge/win-64/libnvjitlink-12.9.86-hac47afa_2.conda @@ -14890,6 +15523,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27343190 timestamp: 1760724535115 @@ -14917,6 +15551,7 @@ packages: - ucrt >=10.0.20348.0 license: BSD-3-Clause license_family: BSD + purls: [] size: 35040 timestamp: 1745826086628 - conda: https://conda.anaconda.org/conda-forge/win-64/libopus-1.6-h6a83c73_0.conda @@ -14928,6 +15563,7 @@ packages: - ucrt >=10.0.20348.0 license: BSD-3-Clause license_family: BSD + purls: [] size: 307249 timestamp: 1765847775174 - conda: https://conda.anaconda.org/conda-forge/win-64/libopus-1.6.1-h6a83c73_0.conda @@ -14939,6 +15575,7 @@ packages: - ucrt >=10.0.20348.0 license: BSD-3-Clause license_family: BSD + purls: [] size: 307373 timestamp: 1768497136248 - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.53-h7351971_0.conda @@ -14950,6 +15587,7 @@ packages: - ucrt >=10.0.20348.0 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 383702 timestamp: 1764981078732 - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.55-h7351971_0.conda @@ -14961,6 +15599,7 @@ packages: - ucrt >=10.0.20348.0 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 383155 timestamp: 1770691504832 - conda: https://conda.anaconda.org/conda-forge/win-64/librsvg-2.60.0-hd5e4115_0.conda @@ -14976,6 +15615,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LGPL-2.1-or-later + purls: [] size: 3336793 timestamp: 1759328441569 - conda: https://conda.anaconda.org/conda-forge/win-64/librsvg-2.60.0-hd5e4115_1.conda @@ -14991,6 +15631,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LGPL-2.1-or-later + purls: [] size: 2877820 timestamp: 1771301866036 - conda: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.21-h6a83c73_3.conda @@ -15012,6 +15653,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: blessing + purls: [] size: 1291059 timestamp: 1764359545703 - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.51.1-hf5d6505_1.conda @@ -15022,6 +15664,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: blessing + purls: [] size: 1292859 timestamp: 1766319616777 - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.52.0-hf5d6505_0.conda @@ -15035,9 +15678,9 @@ packages: purls: [] size: 1297302 timestamp: 1772818899033 -- conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda - sha256: 692dfb73a22c873656d5e393b8f1e2b019a3c8a6486c97cb6900552e64e38c25 - md5: 051f1b2228e7517a2ef8cca5146c8967 +- conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + sha256: 62e1c45ec71ab2e5deeeb0e47e7df6a609991e91d46348f16df50c68fee145c8 + md5: ca0d59f40a02a15e9b5d0ff8db0f85e3 depends: - ucrt >=10.0.20348.0 - vc >=14.3,<15 @@ -15045,9 +15688,9 @@ packages: license: blessing run_exports: weak: - - libsqlite >=3.53.3,<4.0a0 - size: 1315909 - timestamp: 1782519131898 + - libsqlite >=3.53.4,<4.0a0 + size: 1313790 + timestamp: 1785016158097 - conda: https://conda.anaconda.org/conda-forge/win-64/libstdcxx-15.2.0-hae5796f_16.conda sha256: 6d4b74aa2b668ea3927615055ff7557c50628f073a00a504d3fbedbb6eccca43 md5: 7ca89b8b412282e8b8b644f55056279e @@ -15058,6 +15701,7 @@ packages: - libstdcxx-ng ==15.2.0=*_16 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 6461950 timestamp: 1765260469617 - conda: https://conda.anaconda.org/conda-forge/win-64/libstdcxx-15.2.0-hae5796f_18.conda @@ -15070,6 +15714,7 @@ packages: - libstdcxx-ng ==15.2.0=*_18 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 6462596 timestamp: 1771382223989 - conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.1-h8f73337_1.conda @@ -15086,6 +15731,7 @@ packages: - vc14_runtime >=14.44.35208 - zstd >=1.5.7,<1.6.0a0 license: HPND + purls: [] size: 993166 timestamp: 1762022118895 - conda: https://conda.anaconda.org/conda-forge/win-64/libusb-1.0.29-h1839187_0.conda @@ -15099,6 +15745,7 @@ packages: - vc14_runtime >=14.29.30139 - ucrt >=10.0.20348.0 license: LGPL-2.1-or-later + purls: [] size: 118204 timestamp: 1748856290542 - conda: https://conda.anaconda.org/conda-forge/win-64/libvorbis-1.3.7-h5112557_2.conda @@ -15115,6 +15762,7 @@ packages: - libogg >=1.3.5,<1.4.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 243401 timestamp: 1753879416570 - conda: https://conda.anaconda.org/conda-forge/win-64/libvulkan-loader-1.4.328.1-h477610d_0.conda @@ -15131,6 +15779,7 @@ packages: - libvulkan-headers 1.4.328.1.* license: Apache-2.0 license_family: APACHE + purls: [] size: 280488 timestamp: 1759972163692 - conda: https://conda.anaconda.org/conda-forge/win-64/libvulkan-loader-1.4.341.0-h477610d_0.conda @@ -15144,6 +15793,7 @@ packages: - libvulkan-headers 1.4.341.0.* license: Apache-2.0 license_family: APACHE + purls: [] size: 282251 timestamp: 1770077165680 - conda: https://conda.anaconda.org/conda-forge/win-64/libwebp-base-1.6.0-h4d5522a_0.conda @@ -15157,6 +15807,7 @@ packages: - libwebp 1.6.0 license: BSD-3-Clause license_family: BSD + purls: [] size: 279176 timestamp: 1752159543911 - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_10.conda @@ -15186,6 +15837,7 @@ packages: - libxml2 2.15.1 license: MIT license_family: MIT + purls: [] size: 518616 timestamp: 1761016240185 - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.1-h3cfd58e_1.conda @@ -15203,6 +15855,7 @@ packages: - libxml2 2.15.1 license: MIT license_family: MIT + purls: [] size: 518964 timestamp: 1766327232819 - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.2-h3cfd58e_0.conda @@ -15220,6 +15873,7 @@ packages: - libxml2 2.15.2 license: MIT license_family: MIT + purls: [] size: 520731 timestamp: 1772704723763 - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.2-h692994f_0.conda @@ -15254,6 +15908,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 43387 timestamp: 1766327259710 - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.1-ha29bfb0_0.conda @@ -15270,6 +15925,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 43042 timestamp: 1761016261024 - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.2-h5d26750_0.conda @@ -15304,6 +15960,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 43866 timestamp: 1772704745691 - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda @@ -15317,6 +15974,7 @@ packages: - zlib 1.3.1 *_2 license: Zlib license_family: Other + purls: [] size: 55476 timestamp: 1727963768015 - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda @@ -15336,6 +15994,22 @@ packages: - libzlib >=1.3.2,<2.0a0 size: 58347 timestamp: 1774072851498 +- conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + sha256: 0629c2cc0404d3bb29d6baa7b4ba62da80797015e86de050db81ea5a07050527 + md5: 5d2ff29d465097458cc3ff6569151991 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 58529 + timestamp: 1785276664143 - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.8-h4fa8253_0.conda sha256: 145c4370abe870f10987efa9fc15a8383f1dab09abbc9ad4ff15a55d45658f7b md5: 0d8b425ac862bcf17e4b28802c9351cb @@ -15348,6 +16022,7 @@ packages: - openmp 21.1.8|21.1.8.* license: Apache-2.0 WITH LLVM-exception license_family: APACHE + purls: [] size: 347566 timestamp: 1765964942856 - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.0-h4fa8253_0.conda @@ -15362,6 +16037,7 @@ packages: - intel-openmp <0.0a0 license: Apache-2.0 WITH LLVM-exception license_family: APACHE + purls: [] size: 347404 timestamp: 1772025050288 - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.2-h4fa8253_0.conda @@ -15387,6 +16063,7 @@ packages: - msys2-conda-epoch <0.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 7539 timestamp: 1747330852019 - conda: https://conda.anaconda.org/conda-forge/win-64/make-4.4.1-h0e40799_2.conda @@ -15429,6 +16106,7 @@ packages: - vc14_runtime >=14.44.35208 license: LicenseRef-IntelSimplifiedSoftwareOct2022 license_family: Proprietary + purls: [] size: 99909095 timestamp: 1761668703167 - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2025.3.0-hac47afa_455.conda @@ -15442,6 +16120,7 @@ packages: - vc14_runtime >=14.44.35208 license: LicenseRef-IntelSimplifiedSoftwareOct2022 license_family: Proprietary + purls: [] size: 100224829 timestamp: 1767634557029 - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2025.3.1-hac47afa_11.conda @@ -15492,6 +16171,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 7588219 timestamp: 1763350950306 - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.4.0-py314h06c3c77_0.conda @@ -15510,6 +16191,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 7301600 timestamp: 1766373809921 - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.4.2-py314h06c3c77_1.conda @@ -15528,6 +16211,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 7309134 timestamp: 1770098414535 - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.4.3-py312ha3f287d_0.conda @@ -15559,6 +16244,7 @@ packages: - vc14_runtime >=14.29.30139 license: BSD-2-Clause license_family: BSD + purls: [] size: 411269 timestamp: 1739401120354 - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.0-h725018a_0.conda @@ -15571,6 +16257,7 @@ packages: - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: Apache + purls: [] size: 9440812 timestamp: 1762841722179 - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.1-hf411b9b_1.conda @@ -15586,9 +16273,9 @@ packages: purls: [] size: 9343023 timestamp: 1769557547888 -- conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - sha256: cb6e7ba0d010ee0d3249ce9886de3d7613d26d9965d4c95666fa66b9c4c31001 - md5: e99f95734a326c0fd4d02bbd995150d4 +- conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + sha256: 2ebff5a1b5793e82495bf33c91fba040e11ff23333c2385ac66d0c3aee2cc14c + md5: a978392692a910ba1c8920ccb1e784b3 depends: - ca-certificates - ucrt >=10.0.20348.0 @@ -15599,8 +16286,8 @@ packages: run_exports: weak: - openssl >=3.6.3,<4.0a0 - size: 9414790 - timestamp: 1781071745579 + size: 9427535 + timestamp: 1785915614585 - conda: https://conda.anaconda.org/conda-forge/win-64/pango-1.56.4-h03d888a_0.conda sha256: dcda7e9bedc1c87f51ceef7632a5901e26081a1f74a89799a3e50dbdc801c0bd md5: 452d6d3b409edead3bd90fc6317cd6d4 @@ -15620,6 +16307,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LGPL-2.1-or-later + purls: [] size: 454854 timestamp: 1751292618315 - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.47-hd2b5f0e_0.conda @@ -15633,6 +16321,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD + purls: [] size: 995992 timestamp: 1763655708300 - conda: https://conda.anaconda.org/conda-forge/win-64/pixman-0.46.4-h5112557_1.conda @@ -15647,6 +16336,7 @@ packages: - ucrt >=10.0.20348.0 license: MIT license_family: MIT + purls: [] size: 542795 timestamp: 1754665193489 - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py312he5662c2_0.conda @@ -15707,6 +16397,7 @@ packages: - vc14_runtime >=14.44.35208 - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 16934169 timestamp: 1764756783162 python_site_packages_path: Lib/site-packages @@ -15731,6 +16422,7 @@ packages: - vc14_runtime >=14.44.35208 - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 16833248 timestamp: 1765020224759 python_site_packages_path: Lib/site-packages @@ -15755,20 +16447,21 @@ packages: - vc14_runtime >=14.44.35208 - zstd >=1.5.7,<1.6.0a0 license: Python-2.0 + purls: [] size: 18273230 timestamp: 1770675442998 python_site_packages_path: Lib/site-packages -- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda - build_number: 100 - sha256: f1acb89cb1a6bec9a94ae9f8e7411839de009cd64d3ac6a6aec4f3d8a481099a - md5: 8333e3ca6f8d1ebcd30b678dd53f0a25 +- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda + build_number: 101 + sha256: 3a9ae901cd853d507d97aa8b72af4b9a572a3f92dcc5bad8a1318f77ff4e0e64 + md5: 67bbf51f88a2053513d7c78f485f7479 depends: - bzip2 >=1.0.8,<2.0a0 - libexpat >=2.8.1,<3.0a0 - libffi >=3.5.2,<3.6.0a0 - liblzma >=5.8.3,<6.0a0 - libmpdec >=4.0.0,<5.0a0 - - libsqlite >=3.53.2,<4.0a0 + - libsqlite >=3.53.3,<4.0a0 - libzlib >=1.3.2,<2.0a0 - openssl >=3.5.7,<4.0a0 - python_abi 3.14.* *_cp314 @@ -15784,8 +16477,8 @@ packages: - python_abi 3.14.* *_cp314 noarch: - python - size: 18481352 - timestamp: 1781256034828 + size: 18338767 + timestamp: 1784911044838 python_site_packages_path: Lib/site-packages - conda: https://conda.anaconda.org/conda-forge/win-64/pywin32-311-py312h829343e_1.conda sha256: a7505522048dad63940d06623f07eb357b9b65510a8d23ff32b99add05aac3a1 @@ -15902,6 +16595,7 @@ packages: - ucrt >=10.0.20348.0 - sdl3 >=3.2.22,<4.0a0 license: Zlib + purls: [] size: 572101 timestamp: 1757842925694 - conda: https://conda.anaconda.org/conda-forge/win-64/sdl3-3.2.28-h5112557_0.conda @@ -15914,6 +16608,7 @@ packages: - libusb >=1.0.29,<2.0a0 - libvulkan-loader >=1.4.328.1,<2.0a0 license: Zlib + purls: [] size: 1520902 timestamp: 1764713305315 - conda: https://conda.anaconda.org/conda-forge/win-64/sdl3-3.2.30-h5112557_0.conda @@ -15926,6 +16621,7 @@ packages: - libusb >=1.0.29,<2.0a0 - libvulkan-loader >=1.4.328.1,<2.0a0 license: Zlib + purls: [] size: 1521101 timestamp: 1767236315915 - conda: https://conda.anaconda.org/conda-forge/win-64/sdl3-3.4.2-h5112557_0.conda @@ -15938,6 +16634,7 @@ packages: - libvulkan-loader >=1.4.341.0,<2.0a0 - libusb >=1.0.29,<2.0a0 license: Zlib + purls: [] size: 1669623 timestamp: 1771668231217 - conda: https://conda.anaconda.org/conda-forge/win-64/shaderc-2025.5-h8fa7867_1.conda @@ -15951,6 +16648,7 @@ packages: - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: Apache + purls: [] size: 1558909 timestamp: 1770208850155 - conda: https://conda.anaconda.org/conda-forge/win-64/shaderc-2025.5-haa9a63f_0.conda @@ -15964,6 +16662,7 @@ packages: - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: Apache + purls: [] size: 1516952 timestamp: 1764288127996 - conda: https://conda.anaconda.org/conda-forge/win-64/spirv-tools-2025.4-h49e36cd_0.conda @@ -15977,6 +16676,7 @@ packages: - spirv-headers >=1.4.328.0,<1.4.328.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 14158518 timestamp: 1759806206089 - conda: https://conda.anaconda.org/conda-forge/win-64/spirv-tools-2026.1-h49e36cd_0.conda @@ -15990,6 +16690,7 @@ packages: - spirv-headers >=1.4.341.0,<1.4.341.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 13881533 timestamp: 1770089875437 - conda: https://conda.anaconda.org/conda-forge/win-64/sqlalchemy-2.0.49-py312he5662c2_0.conda @@ -16018,6 +16719,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-2-Clause license_family: BSD + purls: [] size: 1862756 timestamp: 1756086862067 - conda: https://conda.anaconda.org/conda-forge/win-64/svt-av1-4.0.1-hac47afa_0.conda @@ -16029,6 +16731,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-2-Clause license_family: BSD + purls: [] size: 1808810 timestamp: 1769664619287 - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2022.3.0-h3155e25_2.conda @@ -16054,6 +16757,7 @@ packages: - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: APACHE + purls: [] size: 155714 timestamp: 1762510341121 - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_3.conda @@ -16065,6 +16769,7 @@ packages: - vc14_runtime >=14.29.30139 license: TCL license_family: BSD + purls: [] size: 3472313 timestamp: 1763055164278 - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda @@ -16118,17 +16823,17 @@ packages: run_exports: {} size: 694692 timestamp: 1756385147981 -- conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda - sha256: 2275f79774c48a0bdb97f7ec7a75ed66d5fbbc8b1cca22d9be74a0dcab046189 - md5: 6e29fdc78a0e55d92d2d38b2b3149735 +- conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + sha256: 15fdcce34c19c3dde9eab5550cd4eb9760cab80eb4e26305643b5cf0fd43d9be + md5: d791fa67f9e790de3bcb4961f3cfb145 depends: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 - ucrt >=10.0.20348.0 license: Apache-2.0 OR MIT run_exports: {} - size: 21860770 - timestamp: 1784166533243 + size: 15540330 + timestamp: 1785973546861 - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h2b53caa_32.conda sha256: 82250af59af9ff3c6a635dd4c4764c631d854feb334d6747d356d949af44d7cf md5: ef02bbe151253a72b8eda264a935db66 @@ -16138,6 +16843,7 @@ packages: - vc14 license: BSD-3-Clause license_family: BSD + purls: [] size: 18861 timestamp: 1760418772353 - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_34.conda @@ -16152,18 +16858,18 @@ packages: purls: [] size: 19356 timestamp: 1767320221521 -- conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda - sha256: 17693b60cb54f80c60275f003f3bfc1b128af56dbfd65c4fae37c64eeb755ce1 - md5: 2eacea63f545b97342da520df6854276 +- conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + sha256: 35444c55a92e2f7f7ba26bc70f81e56e52344f7d064c0fd4b40a46a58517b79c + md5: aa805b5522c2a98fa286e551a1f48546 depends: - - vc14_runtime >=14.51.36231 + - vc14_runtime >=14.51.36247 track_features: - vc14 license: BSD-3-Clause license_family: BSD run_exports: {} - size: 20362 - timestamp: 1781320968457 + size: 21383 + timestamp: 1785359368566 - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_32.conda sha256: e3a3656b70d1202e0d042811ceb743bd0d9f7e00e2acdf824d231b044ef6c0fd md5: 378d5dcec45eaea8d303da6f00447ac0 @@ -16174,6 +16880,7 @@ packages: - vs2015_runtime 14.44.35208.* *_32 license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime license_family: Proprietary + purls: [] size: 682706 timestamp: 1760418629729 - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_34.conda @@ -16189,19 +16896,19 @@ packages: purls: [] size: 683233 timestamp: 1767320219644 -- conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - sha256: 8153ed849c92e891eacac0f2f8d7ecb79f9b5fd7f7917fbb896f252a60a40390 - md5: 06a5bf5a1ca16cce0df6eaa91fc42bc2 +- conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + sha256: 4e4cb599cdc41bf2109d1464c127b5bcbddf548ce3e322e612afb691338b48f8 + md5: ac5333bb3d429361f23adf704cc49a78 depends: - ucrt >=10.0.20348.0 - - vcomp14 14.51.36231 h1b9f54f_39 + - vcomp14 14.51.36247 habf1de7_41 constrains: - - vs2015_runtime 14.51.36231.* *_39 + - vs2015_runtime 14.51.36247.* *_41 license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime license_family: Proprietary run_exports: {} - size: 737434 - timestamp: 1781320964561 + size: 767955 + timestamp: 1785359364369 - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_32.conda sha256: f3790c88fbbdc55874f41de81a4237b1b91eab75e05d0e58661518ff04d2a8a1 md5: 58f67b437acbf2764317ba273d731f1d @@ -16211,6 +16918,7 @@ packages: - vs2015_runtime 14.44.35208.* *_32 license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime license_family: Proprietary + purls: [] size: 114846 timestamp: 1760418593847 - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_34.conda @@ -16225,20 +16933,20 @@ packages: purls: [] size: 115235 timestamp: 1767320173250 -- conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - sha256: 07fb14713c4bc62e2533a2e23a363abfb0e65650681fba0ae4c840e2219350f3 - md5: 8b53a83fda40ec679e4d63fa32fae989 +- conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda + sha256: 731e043390c9457299484d39e427221fc868a9249540a498a5a4f6456c7744d1 + md5: 350bb67a5c8e5f1c53347ac544ab6600 depends: - ucrt >=10.0.20348.0 constrains: - - vs2015_runtime 14.51.36231.* *_39 + - vs2015_runtime 14.51.36247.* *_41 license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime license_family: Proprietary run_exports: strong: - - vcomp14 >=14.51.36231 - size: 120684 - timestamp: 1781320948530 + - vcomp14 >=14.51.36247 + size: 155910 + timestamp: 1785359349999 - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_32.conda sha256: 65cea43f4de99bc81d589e746c538908b2e95aead9042fecfbc56a4d14684a87 md5: dfc1e5bbf1ecb0024a78e4e8bd45239d @@ -16246,6 +16954,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD + purls: [] size: 18919 timestamp: 1760418632059 - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_34.conda @@ -16255,11 +16964,12 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD + purls: [] size: 19347 timestamp: 1767320221943 -- conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda - sha256: 434b4f517b7119675930d17749bf123558271f3f316b217f7ac759e6d7121e9d - md5: 59f1d09ae752b761542975d7b6ad1b89 +- conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_41.conda + sha256: 9d7d1b43cf4af5a8e8b1646175c9f899ffbcab189a33ac41127a96e7bcf41af0 + md5: 04190e0ebd886433300ce9343ee98942 depends: - vswhere constrains: @@ -16273,8 +16983,8 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 - ucrt >=10.0.20348.0 - size: 24190 - timestamp: 1781320983107 + size: 25462 + timestamp: 1785358620723 - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 sha256: 97166b318f8c68ffe4d50b2f4bd36e415219eeaef233e7d41c54244dc6108249 md5: 19e39905184459760ccb8cf5c75f148b @@ -16283,6 +16993,7 @@ packages: - vs2015_runtime >=14.16.27033 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 1041889 timestamp: 1660323726084 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 @@ -16293,6 +17004,7 @@ packages: - vs2015_runtime >=14.16.27033 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 5517425 timestamp: 1646611941216 - conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h6a83c73_3.conda @@ -16340,11 +17052,11 @@ packages: - zstd >=1.5.7,<1.6.0a0 size: 388453 timestamp: 1764777142545 -- conda_source: cuda-bindings[04818863] @ . +- conda_source: cuda-bindings[33376fba] @ . variants: c_stdlib: sysroot c_stdlib_version: '2.28' - cuda_version: 12.* + cuda_version: 13.3.* python: 3.14.* target_platform: linux-64 depends: @@ -16354,14 +17066,14 @@ packages: - cuda-pathfinder - libnvjitlink - cuda-nvrtc - - cuda-nvrtc >=12.9.86,<13.0a0 + - cuda-nvrtc >=13.3.33,<14.0a0 - cuda-nvvm - libnvfatbin - libcufile - - libcufile >=1.14.1.1,<2.0a0 - - libgcc >=15 - - libgcc >=15 - - libstdcxx >=15 + - libcufile >=1.18.1.6,<2.0a0 + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 - __glibc >=2.28,<3.0.a0 - python_abi 3.14.* *_cp314 license: Apache-2.0 @@ -16372,78 +17084,79 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.46.1-default_h4852527_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-15.2.0-he0086c7_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-15.2.0-h7be306e_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-15.2.0-hda75c37_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-15.2.0-hcb00b6d_27.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-16.1.0-h5fcb69b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-16.1.0-h5fd2508_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-16.1.0-he33a5f8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-16.1.0-h5525346_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-16.1.0-hf2715c6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.2.0-hd446a21_119.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-16.1.0-h59071f9_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-16.1.0-h41cdd0d_101.conda - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.9.79-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.9.79-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.9.79-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.9.86-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-12.9.86-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-12.9.86-h69a702a_6.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.9.86-h4bc722e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.9.86-h4bc722e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.9.79-h7938cbb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-13.3.73-h69a702a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.73-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.73-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-hd0affe5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.14.1.1-hbc026e6_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.14.1.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.18.1.6-h053a66a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.18.1.6-h676940d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rdma-core-63.0-h192683f_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.11.29-h2112641_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.9.27-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.9.86-ha770c72_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.9.79-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.9.79-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.9.79-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.9.86-ha770c72_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.73-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder -- conda_source: cuda-bindings[341f49d8] @ . + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder +- conda_source: cuda-bindings[38bd5059] @ . variants: c_compiler: vs2022 cuda_version: 12.* @@ -16470,9 +17183,9 @@ packages: path: ../cuda_pathfinder build_packages: - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_41.conda host_packages: - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-12.9.27-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-12.9.86-h57928b3_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-12.9.79-he0c23c2_0.conda @@ -16480,15 +17193,15 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-12.9.79-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-12.9.86-h57928b3_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-12.9.79-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-dev-12.9.79-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-static-12.9.79-he0c23c2_0.conda @@ -16498,28 +17211,28 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-12.9.86-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-12.9.86-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-profiler-api-12.9.79-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder -- conda_source: cuda-bindings[5987685b] @ . + - conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder +- conda_source: cuda-bindings[595e6447] @ . variants: c_stdlib: sysroot c_stdlib_version: '2.28' - cuda_version: 13.3.* + cuda_version: 12.* python: 3.14.* target_platform: linux-64 depends: @@ -16529,14 +17242,14 @@ packages: - cuda-pathfinder - libnvjitlink - cuda-nvrtc - - cuda-nvrtc >=13.3.33,<14.0a0 + - cuda-nvrtc >=12.9.86,<13.0a0 - cuda-nvvm - libnvfatbin - libcufile - - libcufile >=1.18.1.6,<2.0a0 - - libgcc >=15 - - libgcc >=15 - - libstdcxx >=15 + - libcufile >=1.14.1.1,<2.0a0 + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 - __glibc >=2.28,<3.0.a0 - python_abi 3.14.* *_cp314 license: Apache-2.0 @@ -16547,183 +17260,79 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.46.1-default_h4852527_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-15.2.0-he0086c7_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-15.2.0-h7be306e_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-15.2.0-hda75c37_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-15.2.0-hcb00b6d_27.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-16.1.0-h5fcb69b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-16.1.0-h5fd2508_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-16.1.0-he33a5f8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-16.1.0-h5525346_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-16.1.0-hf2715c6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.2.0-hd446a21_119.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-16.1.0-h59071f9_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-16.1.0-h41cdd0d_101.conda - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-13.3.33-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-13.3.33-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-13.3.73-h69a702a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.73-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.73-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.9.86-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-12.9.86-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-12.9.86-h69a702a_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.9.86-h4bc722e_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.9.86-h4bc722e_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.9.79-h7938cbb_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-hd0affe5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.18.1.6-h053a66a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.18.1.6-h676940d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.14.1.1-hbc026e6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.14.1.1-hecca717_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rdma-core-63.0-h192683f_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.11.29-h2112641_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.73-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder -- conda_source: cuda-bindings[748b2e6f] @ . - variants: - c_stdlib: sysroot - c_stdlib_version: '2.28' - cuda_version: 12.* - python: 3.14.* - target_platform: linux-aarch64 - depends: - - python - - python >=3.10 - - cuda-version - - cuda-pathfinder - - libnvjitlink - - cuda-nvrtc - - cuda-nvrtc >=12.9.86,<13.0a0 - - cuda-nvvm - - libnvfatbin - - libcufile - - libcufile >=1.14.1.1,<2.0a0 - - libgcc >=15 - - libgcc >=15 - - libstdcxx >=15 - - __glibc >=2.28,<3.0.a0 - - python_abi 3.14.* *_cp314 - license: Apache-2.0 - source_depends: - cuda-pathfinder: - path: ../cuda_pathfinder - build_packages: - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - host_packages: - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-12.9.86-h8f3c8d4_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-dev-12.9.86-h8f3c8d4_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-12.9.86-he9431aa_106.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-12.9.86-h7b14b0b_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-12.9.86-h7b14b0b_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-12.9.79-h16bee8c_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.14.1.1-had8bf56_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-dev-1.14.1.1-he38c790_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-12.9.27-h579c4fd_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-12.9.86-h579c4fd_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.9.27-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.9.86-ha770c72_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder -- conda_source: cuda-bindings[8de8dc46] @ . + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder +- conda_source: cuda-bindings[943c652a] @ . variants: c_compiler: vs2022 cuda_version: 13.3.* @@ -16750,25 +17359,25 @@ packages: path: ../cuda_pathfinder build_packages: - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_41.conda host_packages: - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-13.3.73-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_win-64-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-13.3.73-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-dev-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-static-13.3.29-hac47afa_0.conda @@ -16778,24 +17387,24 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.73-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-13.3.73-h2466b09_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-profiler-api-13.3.27-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.8-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder -- conda_source: cuda-bindings[d33f8c8b] @ . + - conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder +- conda_source: cuda-bindings[9909e402] @ . variants: c_stdlib: sysroot c_stdlib_version: '2.28' @@ -16814,9 +17423,9 @@ packages: - libnvfatbin - libcufile - libcufile >=1.18.1.6,<2.0a0 - - libgcc >=15 - - libgcc >=15 - - libstdcxx >=15 + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 - __glibc >=2.28,<3.0.a0 - python_abi 3.14.* *_cp314 license: Apache-2.0 @@ -16827,25 +17436,25 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-16.1.0-h04da0f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-16.1.0-hed00b63_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-16.1.0-hd5c6868_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-16.1.0-h4223dcb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-16.1.0-h2510bd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-16.1.0-hd673532_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-16.1.0-h2445e1f_101.conda - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda @@ -16855,123 +17464,188 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.73-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.8-py314hc6b4731_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-dev-1.18.1.6-he38c790_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.73-h579c4fd_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder -- conda_source: cuda-pathfinder[169735b8] @ ../cuda_pathfinder + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder +- conda_source: cuda-bindings[cb9a5e74] @ . variants: - target_platform: noarch + c_stdlib: sysroot + c_stdlib_version: '2.28' + cuda_version: 12.* + python: 3.14.* + target_platform: linux-aarch64 depends: + - python - python >=3.10 - - python * + - cuda-version + - cuda-pathfinder + - libnvjitlink + - cuda-nvrtc + - cuda-nvrtc >=12.9.86,<13.0a0 + - cuda-nvvm + - libnvfatbin + - libcufile + - libcufile >=1.14.1.1,<2.0a0 + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 + - __glibc >=2.28,<3.0.a0 + - python_abi 3.14.* *_cp314 license: Apache-2.0 - host_packages: - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + source_depends: + cuda-pathfinder: + path: ../cuda_pathfinder + build_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-16.1.0-h04da0f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-16.1.0-hed00b63_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-16.1.0-hd5c6868_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-16.1.0-h4223dcb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-16.1.0-h2510bd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-16.1.0-hd673532_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-16.1.0-h2445e1f_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda -- conda_source: cuda-pathfinder[4dfff30f] @ ../cuda_pathfinder - variants: - target_platform: noarch - depends: - - python >=3.10 - - python * - license: Apache-2.0 host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-12.9.86-h8f3c8d4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-dev-12.9.86-h8f3c8d4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-12.9.86-he9431aa_106.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-12.9.86-h7b14b0b_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-12.9.86-h7b14b0b_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-12.9.79-h16bee8c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.14.1.1-had8bf56_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-dev-1.14.1.1-he38c790_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-12.9.27-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder +- conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder + variants: + target_platform: noarch + depends: + - python >=3.10 + - python * + license: Apache-2.0 + host_packages: + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda -- conda_source: cuda-pathfinder[83159de6] @ ../cuda_pathfinder + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda +- conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder variants: target_platform: noarch depends: @@ -16980,34 +17654,75 @@ packages: license: Apache-2.0 host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.11.29-h2112641_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda +- conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder + variants: + target_platform: noarch + depends: + - python >=3.10 + - python * + license: Apache-2.0 + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda +- pypi: ../cuda_python_test_helpers + name: cuda-python-test-helpers + requires_python: '>=3.10' - pypi: https://files.pythonhosted.org/packages/8c/79/017fab2f7167a9a9795665f894d04f77aafceca80821b51589bb4b23ff5c/nvidia_sphinx_theme-0.0.9.post1-py3-none-any.whl name: nvidia-sphinx-theme version: 0.0.9.post1 diff --git a/cuda_bindings/pixi.toml b/cuda_bindings/pixi.toml index 7c228cbdf99..9d122d17413 100644 --- a/cuda_bindings/pixi.toml +++ b/cuda_bindings/pixi.toml @@ -15,15 +15,15 @@ cuda-version = ["12.*", "13.3.*"] [feature.test.dependencies] cuda-bindings = { path = "." } pytest = ">=6.2.4" - -[feature.test.pypi-dependencies] -cuda-python-test-helpers = { path = "../cuda_python_test_helpers", editable = true } pytest-benchmark = ">=3.4.1" pytest-randomly = "*" pytest-repeat = "*" pyglet = ">=2.1.9" numpy = "*" +[feature.test.pypi-dependencies] +cuda-python-test-helpers = { path = "../cuda_python_test_helpers", editable = true } + # Keep this dependency set aligned with cuda_python/docs/environment-docs.yml. [feature.docs.dependencies] cuda-bindings = "13.2.*" diff --git a/cuda_core/pixi.lock b/cuda_core/pixi.lock index a987aeab986..b8f6cbac479 100644 --- a/cuda_core/pixi.lock +++ b/cuda_core/pixi.lock @@ -42,6 +42,8 @@ environments: cu12: channels: - url: https://conda.anaconda.org/conda-forge/ + indexes: + - https://pypi.org/simple packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda @@ -104,15 +106,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.2-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.2-h73754d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.1.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.4-h6548e54_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.2-default_hafda6a7_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwy-1.3.0-h4c17acf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda @@ -147,8 +149,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-h8f1669f_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.52.0-hf4e2dac_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.1.0-hdf11a46_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.10-hd0affe5_4.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.10-hd0affe5_4.conda @@ -256,7 +258,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-core[5f946272] @ . + - conda_source: cuda-core[e53261c5] @ . + - pypi: ../cuda_python_test_helpers linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -315,15 +318,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libflac-1.5.0-he9c94f4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.2-h8af1aa0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.2-hdae7a39_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-16.1.0-he9431aa_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.4-hf53f6bf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.2-default_ha470c98_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwy-1.3.0-h81d0cf9_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda @@ -356,8 +359,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-14.3.0-hedb4206_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsndfile-1.2.2-h30591a0_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.52.0-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-16.1.0-hdbbeba8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.10-hf9559e3_4.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.10-hf9559e3_4.conda @@ -461,7 +464,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-core[70e83c84] @ . + - conda_source: cuda-core[6e9d4edb] @ . + - pypi: ../cuda_python_test_helpers win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/backports.strenum-1.3.1-haf276df_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda @@ -611,10 +615,13 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-core[5159f177] @ . + - conda_source: cuda-core[18c68942] @ . + - pypi: ../cuda_python_test_helpers cu13: channels: - url: https://conda.anaconda.org/conda-forge/ + indexes: + - https://pypi.org/simple packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda @@ -672,15 +679,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.2-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.2-h73754d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.1.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.4-h6548e54_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.2-default_hafda6a7_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwy-1.3.0-h4c17acf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda @@ -715,8 +722,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.52.0-hf4e2dac_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.1.0-hdf11a46_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda @@ -821,9 +828,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[91169b48] @ ../cuda_bindings - - conda_source: cuda-core[83c371ca] @ . - - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder + - conda_source: cuda-bindings[6c91bfdd] @ ../cuda_bindings + - conda_source: cuda-core[adf7f1da] @ . + - conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -877,15 +885,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libflac-1.5.0-he9c94f4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.2-h8af1aa0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.2-hdae7a39_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-16.1.0-he9431aa_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.4-hf53f6bf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.2-default_ha470c98_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwy-1.3.0-h81d0cf9_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda @@ -918,8 +926,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsndfile-1.2.2-h30591a0_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.52.0-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-16.1.0-hdbbeba8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda @@ -1020,9 +1028,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings - - conda_source: cuda-core[29d2d05a] @ . - - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder + - conda_source: cuda-bindings[3db1bf41] @ ../cuda_bindings + - conda_source: cuda-core[7b4f4a3f] @ . + - conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/backports.strenum-1.3.1-haf276df_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda @@ -1163,12 +1172,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings - - conda_source: cuda-core[e56c61a7] @ . - - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder + - conda_source: cuda-bindings[4664b262] @ ../cuda_bindings + - conda_source: cuda-core[2b0a529b] @ . + - conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers default: channels: - url: https://conda.anaconda.org/conda-forge/ + indexes: + - https://pypi.org/simple packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda @@ -1226,15 +1238,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.2-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.2-h73754d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.1.0-h69a702a_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.4-h6548e54_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.2-default_hafda6a7_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwy-1.3.0-h4c17acf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda @@ -1269,8 +1281,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.52.0-hf4e2dac_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.1.0-hdf11a46_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda @@ -1375,9 +1387,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.47-hd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[91169b48] @ ../cuda_bindings - - conda_source: cuda-core[83c371ca] @ . - - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder + - conda_source: cuda-bindings[6c91bfdd] @ ../cuda_bindings + - conda_source: cuda-core[adf7f1da] @ . + - conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers linux-aarch64: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.15.3-he30d5cf_0.conda @@ -1431,15 +1444,15 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libflac-1.5.0-he9c94f4_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.2-h8af1aa0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.2-hdae7a39_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-16.1.0-he9431aa_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.4-hf53f6bf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.2-default_ha470c98_1000.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwy-1.3.0-h81d0cf9_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda @@ -1472,8 +1485,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_18.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsndfile-1.2.2-h30591a0_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.52.0-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-16.1.0-hdbbeba8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda @@ -1574,9 +1587,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda - - conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings - - conda_source: cuda-core[29d2d05a] @ . - - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder + - conda_source: cuda-bindings[3db1bf41] @ ../cuda_bindings + - conda_source: cuda-core[7b4f4a3f] @ . + - conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers win-64: - conda: https://conda.anaconda.org/conda-forge/noarch/backports.strenum-1.3.1-haf276df_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-h4c7d964_0.conda @@ -1717,9 +1731,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/x265-3.5-h2d74725_3.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings - - conda_source: cuda-core[e56c61a7] @ . - - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder + - conda_source: cuda-bindings[4664b262] @ ../cuda_bindings + - conda_source: cuda-core[2b0a529b] @ . + - conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder + - pypi: ../cuda_python_test_helpers docs: channels: - url: https://conda.anaconda.org/conda-forge/ @@ -3689,6 +3704,7 @@ packages: - libgcc >=14 license: LGPL-2.1-or-later license_family: GPL + purls: [] size: 584660 timestamp: 1768327524772 - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.16.1-hb03c661_0.conda @@ -3722,6 +3738,7 @@ packages: - libstdcxx-ng >=12 license: BSD-2-Clause license_family: BSD + purls: [] size: 2706396 timestamp: 1718551242397 - conda: https://conda.anaconda.org/conda-forge/linux-64/attr-2.5.2-h39aace5_0.conda @@ -3732,6 +3749,7 @@ packages: - libgcc >=13 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 68072 timestamp: 1756738968573 - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_101.conda @@ -3743,6 +3761,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 3744895 timestamp: 1770267152681 - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda @@ -3784,6 +3803,19 @@ packages: - pkg:pypi/brotli?source=hash-mapping size: 367376 timestamp: 1764017265553 +- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + sha256: 1a0d382c515ebf55f8ee1f38c8b81bc95af5c2acc42ad53b66bc5df932032f96 + md5: e675fabcf81499adc7edf58124fb1e01 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: bzip2-1.0.6 + license_family: BSD + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 257808 + timestamp: 1785906269155 - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda sha256: 0b75d45f0bba3e95dc693336fa51f40ea28c980131fec438afb7ce6118ed05f6 md5: d2ffd7602c02f2b316fd921d39876885 @@ -3846,6 +3878,7 @@ packages: - gcc_impl_linux-64 >=14.3.0,<14.3.1.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 31705 timestamp: 1771378159534 - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-bindings-12.9.6-py314h7ea930b_0.conda @@ -3867,6 +3900,8 @@ packages: - cuda-cudart >=12,<13.0a0 - cuda-python >=12.9.6,<12.10.0a0 license: LicenseRef-NVIDIA-SOFTWARE-LICENSE + purls: + - pkg:pypi/cuda-bindings?source=hash-mapping size: 4451465 timestamp: 1773288432998 - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-bindings-12.9.7-py314hadd79bd_1.conda @@ -3919,6 +3954,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 29138 timestamp: 1753975252445 @@ -3940,6 +3976,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23242 timestamp: 1749218416505 @@ -3969,6 +4006,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -3986,6 +4024,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=13.3.29,<14.0a0 @@ -4001,6 +4040,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23283 timestamp: 1749218442382 @@ -4014,6 +4054,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24626 timestamp: 1779898435744 @@ -4054,6 +4095,7 @@ packages: constrains: - gcc_impl_linux-64 >=6,<15.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27215 timestamp: 1753975546846 @@ -4070,6 +4112,7 @@ packages: constrains: - gcc_impl_linux-64 >=6,<15.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27380012 timestamp: 1753975454194 @@ -4108,6 +4151,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 67168282 timestamp: 1760723629347 @@ -4136,6 +4180,7 @@ packages: constrains: - cuda-nvrtc-static >=12.9.86 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-nvrtc >=12.9.86,<13.0a0 @@ -4153,6 +4198,7 @@ packages: constrains: - cuda-nvrtc-static >=13.3.33 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-nvrtc >=13.3.33,<14.0a0 @@ -4199,6 +4245,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 21425520 timestamp: 1753975283188 @@ -4232,6 +4279,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24246736 timestamp: 1753975332907 @@ -4264,6 +4312,7 @@ packages: - cuda-cudart-dev - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23668 timestamp: 1761098836058 @@ -4274,6 +4323,7 @@ packages: - cuda-cudart-dev - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 25007 timestamp: 1779913616712 @@ -4454,6 +4504,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 12485347 timestamp: 1773008832077 - conda: https://conda.anaconda.org/conda-forge/linux-64/ffmpeg-8.1.1-gpl_h6d6c1bd_904.conda @@ -4610,6 +4661,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 270705 timestamp: 1771382710863 - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.18.1-h27c8c51_0.conda @@ -4635,6 +4687,7 @@ packages: - libfreetype 2.14.2 ha770c72_0 - libfreetype6 2.14.2 h73754d4_0 license: GPL-2.0-only OR FTL + purls: [] size: 174292 timestamp: 1772757205296 - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_0.conda @@ -4665,6 +4718,7 @@ packages: - gcc_impl_linux-64 14.3.0 hbdf3cc3_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 29506 timestamp: 1771378321585 - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-15.2.0-h6f77f03_18.conda @@ -4676,6 +4730,7 @@ packages: - gcc_no_conda_specs license: BSD-3-Clause license_family: BSD + purls: [] size: 29453 timestamp: 1771378662937 - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hbdf3cc3_18.conda @@ -4692,6 +4747,7 @@ packages: - sysroot_linux-64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 76302378 timestamp: 1771378056505 - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-15.2.0-he0086c7_19.conda @@ -4725,8 +4781,26 @@ packages: - sysroot_linux-64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 81814135 timestamp: 1771378369317 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-16.1.0-h5fcb69b_1.conda + sha256: 00c87015522248adb5565a1b8f977cfe927831dd7ef0cb0a5d13f896844af719 + md5: 419982d8913246db404319048e062d3e + depends: + - binutils_impl_linux-64 >=2.46.1 + - libgcc >=16.1.0 + - libgcc-devel_linux-64 16.1.0 h59071f9_101 + - libgomp >=16.1.0 + - libsanitizer 16.1.0 hf2715c6_1 + - libstdcxx >=16.1.0 + - libstdcxx-devel_linux-64 16.1.0 h41cdd0d_101 + - sysroot_linux-64 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 85161422 + timestamp: 1785375529345 - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-15.2.0-h7be306e_27.conda sha256: b24b13d467898a9b9a17a868a2686412a98f8935dc7cc51547dd90645d4e8436 md5: 28bc49875f9c38e2401696b3e48d0798 @@ -4741,6 +4815,20 @@ packages: - libgcc >=15 size: 29330 timestamp: 1781279944230 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-16.1.0-h5fd2508_0.conda + sha256: 22d2b2c0386fda70971c87afd4926cb20ba1a247421f5be617c43512570fa4f7 + md5: 15b9577e4be98443deb42e88e9c44656 + depends: + - gcc_impl_linux-64 16.1.0.* + - binutils_linux-64 + - sysroot_linux-64 + license: BSD-3-Clause + license_family: BSD + run_exports: + strong: + - libgcc >=16 + size: 29720 + timestamp: 1785386616206 - conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.44.5-h2b0a6b4_1.conda sha256: b2a6fb56b8f2d576a3ae5e6c57b2dbab91d52d1f1658bf1b258747ae25bb9fde md5: 7eb4977dd6f60b3aaab0715a0ea76f11 @@ -4754,6 +4842,7 @@ packages: - libtiff >=4.7.1,<4.8.0a0 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 575109 timestamp: 1771530561157 - conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.44.6-h2b0a6b4_0.conda @@ -4782,6 +4871,7 @@ packages: - spirv-tools >=2026,<2027.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1353008 timestamp: 1770195199411 - conda: https://conda.anaconda.org/conda-forge/linux-64/glslang-16.3.0-h96af755_0.conda @@ -4831,6 +4921,7 @@ packages: - libstdcxx >=14 license: LGPL-2.0-or-later license_family: LGPL + purls: [] size: 99596 timestamp: 1755102025473 - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-hecca717_0.conda @@ -4868,6 +4959,7 @@ packages: - gxx_impl_linux-64 14.3.0 h2185e75_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 28883 timestamp: 1771378355605 - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-15.2.0-h76987e4_18.conda @@ -4878,6 +4970,7 @@ packages: - gxx_impl_linux-64 15.2.0 hda75c37_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 28723 timestamp: 1771378698305 - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-h2185e75_18.conda @@ -4890,6 +4983,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 14566100 timestamp: 1771378271421 - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-15.2.0-hda75c37_18.conda @@ -4902,6 +4996,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 15587873 timestamp: 1771378609722 - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-15.2.0-hda75c37_19.conda @@ -4917,6 +5012,19 @@ packages: run_exports: {} size: 16356816 timestamp: 1778269332159 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-16.1.0-he33a5f8_1.conda + sha256: 4b7e7a082fab18a58409b05c2611b8edb4aeb06ee07be380a73da5de911da2ba + md5: aaeab97072d79e7945182dc7d4e1a035 + depends: + - gcc_impl_linux-64 16.1.0 h5fcb69b_1 + - libstdcxx-devel_linux-64 16.1.0 h41cdd0d_101 + - sysroot_linux-64 + - tzdata + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 16633585 + timestamp: 1785375706410 - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-15.2.0-hcb00b6d_27.conda sha256: f78da7a8b49943a6ce48372a5bc85ab741ac86666f1040e8876545065ec1096e md5: 5e194579a5f72c70102f342aa362f5f9 @@ -4933,6 +5041,22 @@ packages: - libgcc >=15 size: 27848 timestamp: 1781279944230 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-16.1.0-h5525346_0.conda + sha256: c8c0b721dadcc8d48d2a5a9ee56add4b46ce5427adbf6ff685e0f75fabd52cbd + md5: 4521cfa739a42179511b351566374c6e + depends: + - gxx_impl_linux-64 16.1.0.* + - gcc_linux-64 ==16.1.0 h5fd2508_0 + - binutils_linux-64 + - sysroot_linux-64 + license: BSD-3-Clause + license_family: BSD + run_exports: + strong: + - libstdcxx >=16 + - libgcc >=16 + size: 28116 + timestamp: 1785386616206 - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-13.1.0-h6083320_0.conda sha256: 08dc098dcc5c3445331a834f46602b927cb65d2768189f3f032a6e4643f15cd9 md5: 5baf48da05855be929c5a50f4377794d @@ -4950,6 +5074,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 2615630 timestamp: 1773217509651 - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-14.2.1-h6083320_0.conda @@ -4981,6 +5106,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 12728445 timestamp: 1767969922681 - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda @@ -4995,6 +5121,20 @@ packages: purls: [] size: 12723451 timestamp: 1773822285671 +- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda + sha256: d7c260b7e1cf22ce04d6ba8a86eabf4e6c50bc96a5c27fe2ecb32298af3e88eb + md5: 4ef4b977bb216a3001a3334696a80850 + depends: + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + run_exports: + weak: + - icu >=78.3,<79.0a0 + size: 14455340 + timestamp: 1784916378180 - conda: https://conda.anaconda.org/conda-forge/linux-64/intel-gmmlib-22.10.0-hb700be7_0.conda sha256: bc231d69eb6663db0e09738fb916c5e5507147cf1ac60f364f964004e0b29bab md5: 10909406c1b0e4b57f9f4f0eb0999af8 @@ -5016,6 +5156,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 1009795 timestamp: 1765886047465 - conda: https://conda.anaconda.org/conda-forge/linux-64/intel-media-driver-26.1.4-hecca717_0.conda @@ -5029,6 +5170,7 @@ packages: - libva >=2.23.0,<3.0a0 license: MIT license_family: MIT + purls: [] size: 8783533 timestamp: 1773230300873 - conda: https://conda.anaconda.org/conda-forge/linux-64/intel-media-driver-26.1.6-hecca717_0.conda @@ -5104,6 +5246,7 @@ packages: - binutils_impl_linux-64 2.45.1 license: GPL-3.0-only license_family: GPL + purls: [] size: 725507 timestamp: 1770267139900 - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda @@ -5153,6 +5296,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 858387 timestamp: 1772045965844 - conda: https://conda.anaconda.org/conda-forge/linux-64/level-zero-1.29.0-hb700be7_0.conda @@ -5215,6 +5359,7 @@ packages: - liblapacke 3.11.0 5*_openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18213 timestamp: 1765818813880 - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-5_h5875eb1_mkl.conda @@ -5315,6 +5460,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 121429 timestamp: 1762349484074 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.77-hd0affe5_1.conda @@ -5328,6 +5474,19 @@ packages: purls: [] size: 124432 timestamp: 1774333989027 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-h084b8d7_1.conda + sha256: 8cb25174d6b6fac95d31e86cfe41faffc8ee9dacbf2bfd22e6c23377e8f338c1 + md5: 5db514adf5f843126ff846d1510f22a4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libcap >=2.78,<2.79.0a0 + size: 124306 + timestamp: 1786025967663 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-hd0affe5_0.conda sha256: cc8c9fc6ddf0fbd3d1275b558ae9abad6cda23bced268732e2da21a87bb358cd md5: f9f17eab7f3df1c6fd4b1a548a2f683a @@ -5354,6 +5513,7 @@ packages: - liblapack 3.11.0 5*_openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18194 timestamp: 1765818837135 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-5_hfef963f_mkl.conda @@ -5468,6 +5628,7 @@ packages: - libstdcxx >=14 - rdma-core >=59.0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 969845 timestamp: 1761098818759 @@ -5572,6 +5733,7 @@ packages: - libpciaccess >=0.18,<0.19.0a0 license: MIT license_family: MIT + purls: [] size: 310785 timestamp: 1757212153962 - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.127-hb03c661_0.conda @@ -5606,6 +5768,7 @@ packages: - __glibc >=2.17,<3.0.a0 - libglvnd 1.7.0 ha4b6fd6_2 license: LicenseRef-libglvnd + purls: [] size: 44840 timestamp: 1731330973553 - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_3.conda @@ -5628,6 +5791,7 @@ packages: - expat 2.7.4.* license: MIT license_family: MIT + purls: [] size: 76798 timestamp: 1771259418166 - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.5-hecca717_0.conda @@ -5691,6 +5855,7 @@ packages: depends: - libfreetype6 >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 8035 timestamp: 1772757210108 - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda @@ -5713,6 +5878,7 @@ packages: constrains: - freetype >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 386316 timestamp: 1772757193822 - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda @@ -5758,6 +5924,21 @@ packages: run_exports: {} size: 1041084 timestamp: 1778269013026 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + sha256: d5cb8475131c31680f8fd30512c418f373064e272e452063276a8fb14c9fa42f + md5: 5a7d954665c707c93311657cd779c705 + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + constrains: + - libgomp 16.1.0 he0feb66_1 + - libgcc-ng ==16.1.0=*_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 1057877 + timestamp: 1785375436766 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_18.conda sha256: e318a711400f536c81123e753d4c797a821021fb38970cebfb3f454126016893 md5: d5e96b1ed75ca01906b3d2469b4ce493 @@ -5777,6 +5958,19 @@ packages: purls: [] size: 27694 timestamp: 1778269016987 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.1.0-h69a702a_1.conda + sha256: 225275c562337a1cd61705da0ee4235dde7bba7504de1c34b74c894adb2b0eee + md5: 7ed870c014a6f23c7dfafda53d2763a9 + depends: + - libgcc 16.1.0 ha9f2e26_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libgcc + size: 28210 + timestamp: 1785375440733 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_18.conda sha256: d2c9fad338fd85e4487424865da8e74006ab2e2475bd788f624d7a39b2a72aee md5: 9063115da5bc35fdc3e1002e69b9ef6e @@ -5835,6 +6029,7 @@ packages: - libglvnd 1.7.0 ha4b6fd6_2 - libglx 1.7.0 ha4b6fd6_2 license: LicenseRef-libglvnd + purls: [] size: 134712 timestamp: 1731330998354 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_3.conda @@ -5882,6 +6077,7 @@ packages: constrains: - glib 2.86.4 *_1 license: LGPL-2.1-or-later + purls: [] size: 4398701 timestamp: 1771863239578 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.88.1-h0d30a3d_2.conda @@ -5906,6 +6102,7 @@ packages: depends: - __glibc >=2.17,<3.0.a0 license: LicenseRef-libglvnd + purls: [] size: 132463 timestamp: 1731330968309 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_3.conda @@ -5925,6 +6122,7 @@ packages: - libglvnd 1.7.0 ha4b6fd6_2 - xorg-libx11 >=1.8.10,<2.0a0 license: LicenseRef-libglvnd + purls: [] size: 75504 timestamp: 1731330988898 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_3.conda @@ -5984,6 +6182,19 @@ packages: - _openmp_mutex >=4.5 size: 603817 timestamp: 1778268942614 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + sha256: 62cb599ad0539d99386515326d9d5e8f51f75a60c69c2131b21df76edf35bd89 + md5: 88f2d91cb1533194c323534253094d23 + depends: + - __glibc >=2.17,<3.0.a0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - _openmp_mutex >=4.5 + size: 640415 + timestamp: 1785375373755 - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.12.2-default_hafda6a7_1000.conda sha256: 2cf160794dda62cf93539adf16d26cfd31092829f2a2757dbdd562984c1b110a md5: 0ed3aa3e3e6bc85050d38881673a692f @@ -5995,6 +6206,7 @@ packages: - libxml2-16 >=2.14.6 license: BSD-3-Clause license_family: BSD + purls: [] size: 2449916 timestamp: 1765103845133 - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.13.0-default_he001693_1000.conda @@ -6019,6 +6231,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: Apache-2.0 OR BSD-3-Clause + purls: [] size: 1448617 timestamp: 1758894401402 - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwy-1.4.0-h10be129_0.conda @@ -6051,6 +6264,7 @@ packages: constrains: - jpeg <0.0.0a license: IJG AND BSD-3-Clause AND Zlib + purls: [] size: 633710 timestamp: 1762094827865 - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda @@ -6092,6 +6306,7 @@ packages: - libbrotlidec >=1.2.0,<1.3.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1883476 timestamp: 1770801977654 - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-5_h47877c9_openblas.conda @@ -6106,6 +6321,7 @@ packages: - libcblas 3.11.0 5*_openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18200 timestamp: 1765818857876 - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-5_h5e43f62_mkl.conda @@ -6269,6 +6485,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 30515495 timestamp: 1760723776293 @@ -6292,6 +6509,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libnvptxcompiler-dev_linux-64 12.9.86 ha770c72_2 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27046 timestamp: 1753975516342 @@ -6318,6 +6536,7 @@ packages: - openblas >=0.3.30,<0.3.31.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 5927939 timestamp: 1763114673331 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.32-pthreads_h94d23a6_0.conda @@ -6361,6 +6580,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 6582302 timestamp: 1772727204779 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-2026.2.0-h1f0fae8_1.conda @@ -6401,6 +6621,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 114431 timestamp: 1772727230331 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-batch-plugin-2026.2.0-h7e124b3_1.conda @@ -6441,6 +6662,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 249056 timestamp: 1772727247597 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-auto-plugin-2026.2.0-h7e124b3_1.conda @@ -6481,6 +6703,7 @@ packages: - pugixml >=1.15,<1.16.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 211582 timestamp: 1772727264950 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-hetero-plugin-2026.2.0-hd41364c_0.conda @@ -6522,6 +6745,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 13173323 timestamp: 1772727282718 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-cpu-plugin-2026.2.0-h1f0fae8_1.conda @@ -6566,6 +6790,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 11402462 timestamp: 1772727323957 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-gpu-plugin-2026.2.0-h1f0fae8_1.conda @@ -6612,6 +6837,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 1994640 timestamp: 1772727360780 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-intel-npu-plugin-2026.2.0-h1f0fae8_1.conda @@ -6656,6 +6882,7 @@ packages: - pugixml >=1.15,<1.16.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 192778 timestamp: 1772727380069 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-ir-frontend-2026.2.0-hd41364c_0.conda @@ -6698,6 +6925,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 1860687 timestamp: 1772727397981 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-onnx-frontend-2026.2.0-h7a07914_0.conda @@ -6744,6 +6972,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 684224 timestamp: 1772727417276 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-paddle-frontend-2026.2.0-h7a07914_0.conda @@ -6787,6 +7016,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 1185558 timestamp: 1772727435039 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-pytorch-frontend-2026.2.0-hecca717_0.conda @@ -6828,6 +7058,7 @@ packages: - snappy >=1.2.2,<1.3.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 1257870 timestamp: 1772727453738 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-frontend-2026.2.0-h78e8023_0.conda @@ -6873,6 +7104,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 456585 timestamp: 1772727473378 - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenvino-tensorflow-lite-frontend-2026.2.0-hecca717_0.conda @@ -6919,6 +7151,7 @@ packages: - libgcc >=13 license: MIT license_family: MIT + purls: [] size: 28424 timestamp: 1749901812541 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.19-hb03c661_0.conda @@ -6955,6 +7188,7 @@ packages: - __glibc >=2.17,<3.0.a0 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 317669 timestamp: 1770691470744 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda @@ -6980,6 +7214,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 3638698 timestamp: 1769749419271 - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.33.5-h6eeba95_1.conda @@ -7011,6 +7246,7 @@ packages: constrains: - __glibc >=2.17 license: LGPL-2.1-or-later + purls: [] size: 4011590 timestamp: 1771399906142 - conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.62.3-h4c96295_0.conda @@ -7042,6 +7278,7 @@ packages: - libstdcxx >=14.3.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 7949259 timestamp: 1771377982207 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_18.conda @@ -7053,6 +7290,7 @@ packages: - libstdcxx >=15.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 8095113 timestamp: 1771378289674 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_19.conda @@ -7069,6 +7307,20 @@ packages: - libsanitizer 15.2.0 size: 7930689 timestamp: 1778269054623 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-16.1.0-hf2715c6_1.conda + sha256: 85662ecadd3961bc96cbcc38dbc024a768cc35932c8440677ed028ea6322c36c + md5: abd77210925872ee084672cf5be1d491 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=16.1.0 + - libstdcxx >=16.1.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: + weak: + - libsanitizer 16.1.0 + size: 7780843 + timestamp: 1785375481116 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda sha256: 57cb5f92110324c04498b96563211a1bca6a74b2918b1e8df578bfed03cc32e4 md5: 067590f061c9f6ea7e61e3b2112ed6b3 @@ -7133,6 +7385,20 @@ packages: - libsqlite >=3.53.3,<4.0a0 size: 962119 timestamp: 1782519076616 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + sha256: 72023efc207fe681e26b65fc9d668062cf0b4f0eacf3431e6eb099b95c1f2efd + md5: df088a279cd5e6fd2790b4c196434da1 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=14 + - libzlib >=1.3.2,<2.0a0 + license: blessing + run_exports: + weak: + - libsqlite >=3.53.4,<4.0a0 + size: 964200 + timestamp: 1785016112246 - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_18.conda sha256: 78668020064fdaa27e9ab65cd2997e2c837b564ab26ce3bf0e58a2ce1a525c6e md5: 1b08cd684f34175e4514474793d44bcb @@ -7160,6 +7426,20 @@ packages: run_exports: {} size: 5852044 timestamp: 1778269036376 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + sha256: 79721dd08aeb0ab9e773f1f9ef41cf4e6c17477e3d72319147619045bce05a09 + md5: aed6cf89adc1e9b846e4367ac538e434 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc 16.1.0 ha9f2e26_1 + constrains: + - libstdcxx-ng ==16.1.0=*_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 6631744 + timestamp: 1785375462643 - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_18.conda sha256: 3c902ffd673cb3c6ddde624cdb80f870b6c835f8bf28384b0016e7d444dd0145 md5: 6235adb93d064ecdf3d44faee6f468de @@ -7179,6 +7459,19 @@ packages: purls: [] size: 27776 timestamp: 1778269074600 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.1.0-hdf11a46_1.conda + sha256: 2876ca4463d1b394eb969ce4a84d1620aa63fb8202a6397837d1e45ec76c1208 + md5: c94f06123272d8e129d4acf3a25ffb35 + depends: + - libstdcxx 16.1.0 h934c35e_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libstdcxx + size: 28253 + timestamp: 1785375500257 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.10-hd0affe5_4.conda sha256: f0356bb344a684e7616fc84675cfca6401140320594e8686be30e8ac7547aed2 md5: 1d4c18d75c51ed9d00092a891a547a7d @@ -7187,6 +7480,7 @@ packages: - libcap >=2.77,<2.78.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 491953 timestamp: 1770738638119 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda @@ -7282,6 +7576,7 @@ packages: - libcap >=2.77,<2.78.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 144654 timestamp: 1770738650966 - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda @@ -7350,6 +7645,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 40311 timestamp: 1766271528534 - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42-h5347b49_0.conda @@ -7526,6 +7822,7 @@ packages: - xorg-libxau >=1.0.12,<2.0a0 license: MIT/X11 Derivative license_family: MIT + purls: [] size: 837922 timestamp: 1764794163823 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.13.2-hca5e8e5_0.conda @@ -7559,6 +7856,7 @@ packages: - libxml2 2.15.2 license: MIT license_family: MIT + purls: [] size: 557492 timestamp: 1772704601644 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda @@ -7591,6 +7889,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 45968 timestamp: 1772704614539 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda @@ -7619,6 +7918,7 @@ packages: - zlib 1.3.1 *_2 license: Zlib license_family: Other + purls: [] size: 60963 timestamp: 1727963148474 - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda @@ -7636,6 +7936,20 @@ packages: - libzlib >=1.3.2,<2.0a0 size: 63629 timestamp: 1774072609062 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + sha256: eb8a0db0aa570124f7d2a93d7c7f596e3390df5e047818d873baad32985fc736 + md5: 0de0122d9570a8ab637c6b73db268389 + depends: + - __glibc >=2.17,<3.0.a0 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 63713 + timestamp: 1785362952714 - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.0-h4922eb0_0.conda sha256: 543c9f17cf6ee6d7b635823fb9009df421d510c36739534df6ae43eadaf6ff4e md5: 5e7da5333653c631d27732893b934351 @@ -7701,6 +8015,8 @@ packages: - python_abi 3.14.* *_cp314 - numpy >=1.23,<3 license: MPL-2.0 AND Apache-2.0 + purls: + - pkg:pypi/ml-dtypes?source=hash-mapping size: 345273 timestamp: 1771362516002 - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.3.1-h24ddda3_1.conda @@ -7804,6 +8120,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 8926994 timestamp: 1770098474394 - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.3-py314h2b28147_0.conda @@ -7875,6 +8193,7 @@ packages: - opencl-headers >=2024.10.24 license: BSD-2-Clause license_family: BSD + purls: [] size: 106742 timestamp: 1743700382939 - conda: https://conda.anaconda.org/conda-forge/linux-64/ocl-icd-2.3.4-hb03c661_1.conda @@ -7898,6 +8217,7 @@ packages: - libstdcxx >=13 license: Apache-2.0 license_family: APACHE + purls: [] size: 55357 timestamp: 1749853464518 - conda: https://conda.anaconda.org/conda-forge/linux-64/opencl-headers-2025.06.13-hecca717_0.conda @@ -7951,9 +8271,23 @@ packages: - openssl >=3.6.3,<4.0a0 size: 3159683 timestamp: 1781069855778 -- conda: https://conda.anaconda.org/conda-forge/linux-64/optree-0.19.0-py314h9891dd4_0.conda - sha256: 620379ebc27e1c43b9a8defdb167442a3413de949a464305443833db32ba7a83 - md5: e13172f02effa3c9f07571ed0ddef44d +- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + sha256: 012096056b97abf1f68c46b7146bd2cbd68c1be762340b4f5dad4fbbe99177bc + md5: c5955c27917ff2234def47f075e71e02 + depends: + - __glibc >=2.17,<3.0.a0 + - ca-certificates + - libgcc >=14 + license: Apache-2.0 + license_family: Apache + run_exports: + weak: + - openssl >=3.6.3,<4.0a0 + size: 3182423 + timestamp: 1785913583650 +- conda: https://conda.anaconda.org/conda-forge/linux-64/optree-0.19.0-py314h9891dd4_0.conda + sha256: 620379ebc27e1c43b9a8defdb167442a3413de949a464305443833db32ba7a83 + md5: e13172f02effa3c9f07571ed0ddef44d depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 @@ -7983,6 +8317,7 @@ packages: - libpng >=1.6.49,<1.7.0a0 - libzlib >=1.3.1,<2.0a0 license: LGPL-2.1-or-later + purls: [] size: 455420 timestamp: 1751292466873 - conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.56.4-hda50119_1.conda @@ -8176,6 +8511,38 @@ packages: size: 36717183 timestamp: 1781255094700 python_site_packages_path: lib/python3.14/site-packages +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda + build_number: 101 + sha256: ee8f2006e1724b1f2e9e0ccc5a7cfdcab973460faa2f63ac1f6e44fdad4c0344 + md5: 78975a41cf3c525da654f17e35bfca9e + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - libgcc >=14 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.3,<4.0a0 + - libuuid >=2.42.2,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + run_exports: + weak: + - python_abi 3.14.* *_cp314 + noarch: + - python + size: 36869055 + timestamp: 1784910110714 + python_site_packages_path: lib/python3.14/site-packages - conda: https://conda.anaconda.org/conda-forge/linux-64/pytorch-2.10.0-cuda130_mkl_py314_h382c374_303.conda sha256: d86f460bddc5b3c443b109e30a1c7f1f9b4044eabf6356c49f19dd660720e395 md5: 1a0371ac3f70358740c260541508f0f5 @@ -8449,6 +8816,7 @@ packages: - xorg-libxi >=1.8.2,<2.0a0 - wayland >=1.24.0,<2.0a0 license: Zlib + purls: [] size: 2138749 timestamp: 1771668185803 - conda: https://conda.anaconda.org/conda-forge/linux-64/shaderc-2025.5-h718be3e_1.conda @@ -8462,6 +8830,7 @@ packages: - spirv-tools >=2026,<2027.0a0 license: Apache-2.0 license_family: Apache + purls: [] size: 113513 timestamp: 1770208767759 - conda: https://conda.anaconda.org/conda-forge/linux-64/shaderc-2026.2-h718be3e_0.conda @@ -8513,6 +8882,7 @@ packages: - spirv-headers >=1.4.341.0,<1.4.341.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 2296977 timestamp: 1770089626195 - conda: https://conda.anaconda.org/conda-forge/linux-64/spirv-tools-2026.2-hb700be7_0.conda @@ -8567,6 +8937,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 181329 timestamp: 1767886632911 - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2023.0.0-hab88423_2.conda @@ -8661,6 +9032,19 @@ packages: run_exports: {} size: 20782187 timestamp: 1784166603021 +- conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda + sha256: ac2feff703269655286bf163c4382d3c4830bd2eb4e68e77879a8b4939a2203c + md5: 07c4923f2c89939ec82b77f2ab41c5e9 + depends: + - libgcc >=14 + - libstdcxx >=14 + - __glibc >=2.17,<3.0.a0 + constrains: + - __glibc >=2.17 + license: Apache-2.0 OR MIT + run_exports: {} + size: 17299962 + timestamp: 1785973451439 - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.24.0-hd6090a7_1.conda sha256: 3aa04ae8e9521d9b56b562376d944c3e52b69f9d2a0667f77b8953464822e125 md5: 035da2e4f5770f036ff704fa17aace24 @@ -8672,6 +9056,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 329779 timestamp: 1761174273487 - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.25.0-hd6090a7_0.conda @@ -8730,6 +9115,7 @@ packages: - xorg-libx11 >=1.8.13,<2.0a0 license: MIT license_family: MIT + purls: [] size: 399291 timestamp: 1772021302485 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda @@ -8839,6 +9225,7 @@ packages: - xorg-libxfixes >=6.0.1,<7.0a0 license: MIT license_family: MIT + purls: [] size: 47179 timestamp: 1727799254088 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.3-hb03c661_0.conda @@ -8991,6 +9378,7 @@ packages: - libgcc >=14 license: LGPL-2.1-or-later license_family: GPL + purls: [] size: 615729 timestamp: 1768327548407 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.16.1-he30d5cf_0.conda @@ -9022,6 +9410,7 @@ packages: - libstdcxx-ng >=12 license: BSD-2-Clause license_family: BSD + purls: [] size: 3250813 timestamp: 1718551360260 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/attr-2.5.1-h4e544f5_1.tar.bz2 @@ -9031,6 +9420,7 @@ packages: - libgcc-ng >=12 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 74992 timestamp: 1660065534958 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45.1-default_h5f4c503_101.conda @@ -9042,6 +9432,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 4741684 timestamp: 1770267224406 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda @@ -9083,6 +9474,18 @@ packages: - pkg:pypi/brotli?source=hash-mapping size: 373193 timestamp: 1764017486851 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda + sha256: 24eacc8a20fd7c4616566178562bef7f9344eb4a8700cfc3180fa75a6ff9d39f + md5: fd544ef1c672d645bf78e5819cbb8f91 + depends: + - libgcc >=14 + license: bzip2-1.0.6 + license_family: BSD + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 194694 + timestamp: 1785906301397 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda sha256: b3495077889dde6bb370938e7db82be545c73e8589696ad0843a32221520ad4c md5: 840d8fc0d7b3209be93080bc20e07f2d @@ -9142,6 +9545,7 @@ packages: - gcc_impl_linux-aarch64 >=14.3.0,<14.3.1.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 31474 timestamp: 1771377963347 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-12.9.6-py314h43a89f9_0.conda @@ -9163,6 +9567,8 @@ packages: - cuda-cudart >=12,<13.0a0 - cuda-python >=12.9.6,<12.10.0a0 license: LicenseRef-NVIDIA-SOFTWARE-LICENSE + purls: + - pkg:pypi/cuda-bindings?source=hash-mapping size: 3959387 timestamp: 1773288705142 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-12.9.7-py314hd8c1704_1.conda @@ -9217,6 +9623,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 29186 timestamp: 1753975202369 @@ -9239,6 +9646,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23466 timestamp: 1749218349235 @@ -9268,6 +9676,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -9285,6 +9694,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=13.3.29,<14.0a0 @@ -9300,6 +9710,7 @@ packages: - libgcc >=13 - libstdcxx >=13 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23507 timestamp: 1749218358755 @@ -9313,6 +9724,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24786 timestamp: 1779898447855 @@ -9356,6 +9768,7 @@ packages: constrains: - gcc_impl_linux-aarch64 >=6,<15.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27322 timestamp: 1753975427660 @@ -9372,6 +9785,7 @@ packages: constrains: - gcc_impl_linux-aarch64 >=6,<15.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23974390 timestamp: 1753975366926 @@ -9412,6 +9826,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 33382016 timestamp: 1760723722396 @@ -9441,6 +9856,7 @@ packages: - cuda-nvrtc-static >=12.9.86 - arm-variant * sbsa license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-nvrtc >=12.9.86,<13.0a0 @@ -9459,6 +9875,7 @@ packages: - arm-variant * sbsa - cuda-nvrtc-static >=13.3.33 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-nvrtc >=13.3.33,<14.0a0 @@ -9507,6 +9924,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 21601172 timestamp: 1753975236344 @@ -9540,6 +9958,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libgcc >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24411824 timestamp: 1753975273689 @@ -9573,6 +9992,7 @@ packages: - cuda-cudart-dev - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23784 timestamp: 1761098779882 @@ -9586,6 +10006,7 @@ packages: constrains: - arm-variant * sbsa license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 25101 timestamp: 1779913642980 @@ -9759,6 +10180,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 12035194 timestamp: 1773008913159 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ffmpeg-8.1.1-gpl_hef17b83_904.conda @@ -9903,6 +10325,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 279044 timestamp: 1771382728182 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/fontconfig-2.18.1-hba86a56_0.conda @@ -9927,6 +10350,7 @@ packages: - libfreetype 2.14.2 h8af1aa0_0 - libfreetype6 2.14.2 hdae7a39_0 license: GPL-2.0-only OR FTL + purls: [] size: 173437 timestamp: 1772756019067 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/freetype-2.14.3-h8af1aa0_1.conda @@ -9956,6 +10380,7 @@ packages: - gcc_impl_linux-aarch64 14.3.0 h533bfc8_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 29438 timestamp: 1771378102660 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc-15.2.0-h24a549f_18.conda @@ -9967,6 +10392,7 @@ packages: - gcc_no_conda_specs license: BSD-3-Clause license_family: BSD + purls: [] size: 29408 timestamp: 1771378529822 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-14.3.0-h533bfc8_18.conda @@ -9983,6 +10409,7 @@ packages: - sysroot_linux-aarch64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 69149627 timestamp: 1771377858762 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda @@ -10016,8 +10443,26 @@ packages: - sysroot_linux-aarch64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 73516504 timestamp: 1771378256368 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-16.1.0-h04da0f0_1.conda + sha256: ad024e118ed57e7277547fd03a913b981e9bb9a6db258b8943293b13329d4489 + md5: e5551bb5b75bcc4031e40f2b69baab84 + depends: + - binutils_impl_linux-aarch64 >=2.46.1 + - libgcc >=16.1.0 + - libgcc-devel_linux-aarch64 16.1.0 hd673532_101 + - libgomp >=16.1.0 + - libsanitizer 16.1.0 h2510bd8_1 + - libstdcxx >=16.1.0 + - libstdcxx-devel_linux-aarch64 16.1.0 h2445e1f_101 + - sysroot_linux-aarch64 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 75102801 + timestamp: 1785374604361 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda sha256: 2450913611189cc3c26062a43a97a93501159335d4d314cca5e2678fb5f4d3b6 md5: 619b8a05f89220fa8c9536dcfeeddd5b @@ -10032,6 +10477,20 @@ packages: - libgcc >=15 size: 29074 timestamp: 1781279974207 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-16.1.0-hed00b63_0.conda + sha256: 50305dd8c4198b4a38fca1666589bdaba0d26cf2c69f901391259d5b4b1133a4 + md5: 4cb863693c93536916f84802ea2b520c + depends: + - gcc_impl_linux-aarch64 16.1.0.* + - binutils_linux-aarch64 + - sysroot_linux-aarch64 + license: BSD-3-Clause + license_family: BSD + run_exports: + strong: + - libgcc >=16 + size: 29478 + timestamp: 1785386542583 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gdk-pixbuf-2.44.5-h90308e0_1.conda sha256: aa95b37da0750fb93c5eeef79073b9b0d50976fa0dc02ed0301ff7bbbfc7ff36 md5: c75ae103325db056719dd51d6525e1cd @@ -10044,6 +10503,7 @@ packages: - libtiff >=4.7.1,<4.8.0a0 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 584221 timestamp: 1771532437279 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gdk-pixbuf-2.44.6-h90308e0_0.conda @@ -10070,6 +10530,7 @@ packages: - spirv-tools >=2026,<2027.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1348415 timestamp: 1770195275881 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/glslang-16.3.0-h124e036_0.conda @@ -10117,6 +10578,7 @@ packages: - libstdcxx >=14 license: LGPL-2.0-or-later license_family: LGPL + purls: [] size: 102400 timestamp: 1755102000043 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/graphite2-1.3.15-hfae3067_0.conda @@ -10153,6 +10615,7 @@ packages: - gxx_impl_linux-aarch64 14.3.0 h0d4f5d4_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 28822 timestamp: 1771378129202 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx-15.2.0-ha384071_18.conda @@ -10163,6 +10626,7 @@ packages: - gxx_impl_linux-aarch64 15.2.0 h03e2352_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 28780 timestamp: 1771378557194 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-14.3.0-h0d4f5d4_18.conda @@ -10175,6 +10639,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 13513218 timestamp: 1771378064341 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_18.conda @@ -10187,6 +10652,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 15371317 timestamp: 1771378487467 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda @@ -10202,6 +10668,19 @@ packages: run_exports: {} size: 14640001 timestamp: 1778269082840 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-16.1.0-hd5c6868_1.conda + sha256: 9a8b38dc912b6952e52b554e1eb851da279fd4ead6fee7eac78ee2397be19d40 + md5: b7d0e87c50859580781ed98eb0a70180 + depends: + - gcc_impl_linux-aarch64 16.1.0 h04da0f0_1 + - libstdcxx-devel_linux-aarch64 16.1.0 h2445e1f_101 + - sysroot_linux-aarch64 + - tzdata + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 15592564 + timestamp: 1785374786297 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda sha256: f4bc63d467e2c48c255bc8d2886fb11f6a8d09c1251a6f5b25628abee1768693 md5: ea51d6df068bee183ff667f75bfdc2f6 @@ -10218,6 +10697,22 @@ packages: - libgcc >=15 size: 27620 timestamp: 1781279974207 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-16.1.0-h4223dcb_0.conda + sha256: edfc3ee04478cdfed6b84f58bc1db77818ed92f1d58bd6de565e9a8bacb5a558 + md5: 036c35401710f4b03aba2a0cc5792496 + depends: + - gxx_impl_linux-aarch64 16.1.0.* + - gcc_linux-aarch64 ==16.1.0 hed00b63_0 + - binutils_linux-aarch64 + - sysroot_linux-aarch64 + license: BSD-3-Clause + license_family: BSD + run_exports: + strong: + - libstdcxx >=16 + - libgcc >=16 + size: 27895 + timestamp: 1785386542583 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/harfbuzz-13.1.0-h1134a53_0.conda sha256: 49074457bdc624c0c0f39bb4b9b7689ec6334127ed7d5312484908f48e9a8e20 md5: 811bb5384d92870a3492fab4de4ff3f6 @@ -10234,6 +10729,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 2346492 timestamp: 1773222371375 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/harfbuzz-14.2.1-h1134a53_0.conda @@ -10263,6 +10759,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 12851689 timestamp: 1772208964788 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda @@ -10343,6 +10840,7 @@ packages: - binutils_impl_linux-aarch64 2.45.1 license: GPL-3.0-only license_family: GPL + purls: [] size: 875924 timestamp: 1770267209884 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda @@ -10426,6 +10924,7 @@ packages: - blas 2.305 openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18369 timestamp: 1765818610617 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-6_haddc8a3_openblas.conda @@ -10504,6 +11003,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 108542 timestamp: 1762350753349 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.77-hf9559e3_1.conda @@ -10529,6 +11029,18 @@ packages: - libcap >=2.78,<2.79.0a0 size: 109192 timestamp: 1775490102029 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hfcc8634_1.conda + sha256: 6487e7644d062e18d389c11a9a3183e5a71c2652d05fdd88dbd063ad09f7ad4b + md5: 5e347c665a310b4c148bbb02596ae0c3 + depends: + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libcap >=2.78,<2.79.0a0 + size: 108530 + timestamp: 1786025925536 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-5_hd72aa62_openblas.conda build_number: 5 sha256: 3fad5c9de161dccb4e42c8b1ae8eccb33f4ed56bccbcced9cbb0956ae7869e61 @@ -10541,6 +11053,7 @@ packages: - blas 2.305 openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18371 timestamp: 1765818618899 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-6_hd72aa62_openblas.conda @@ -10658,6 +11171,7 @@ packages: - libstdcxx >=14 - rdma-core >=59.0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 909365 timestamp: 1761098964619 @@ -10772,6 +11286,7 @@ packages: - libpciaccess >=0.18,<0.19.0a0 license: MIT license_family: MIT + purls: [] size: 344548 timestamp: 1757212128414 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdrm-2.4.127-he30d5cf_0.conda @@ -10803,6 +11318,7 @@ packages: depends: - libglvnd 1.7.0 hd24410f_2 license: LicenseRef-libglvnd + purls: [] size: 53551 timestamp: 1731330990477 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libegl-1.7.0-hd24410f_3.conda @@ -10823,6 +11339,7 @@ packages: - expat 2.7.4.* license: MIT license_family: MIT + purls: [] size: 76564 timestamp: 1771259530958 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.7.5-hfae3067_0.conda @@ -10882,6 +11399,7 @@ packages: depends: - libfreetype6 >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 8108 timestamp: 1772756012710 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.3-h8af1aa0_1.conda @@ -10903,6 +11421,7 @@ packages: constrains: - freetype >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 423372 timestamp: 1772756012086 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.3-hdae7a39_1.conda @@ -10945,6 +11464,20 @@ packages: run_exports: {} size: 622462 timestamp: 1778268755949 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + sha256: 88a3d400c678df034c9d498f32503779977d5ea826063687c663e42c945abed5 + md5: 91eb209af1098d652fc69b8a3fc7cbaa + depends: + - _openmp_mutex >=4.5 + constrains: + - libgomp 16.1.0 h8acb6b2_1 + - libgcc-ng ==16.1.0=*_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 628785 + timestamp: 1785374520532 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_18.conda sha256: 83bb0415f59634dccfa8335d4163d1f6db00a27b36666736f9842b650b92cf2f md5: 4feebd0fbf61075a1a9c2e9b3936c257 @@ -10964,6 +11497,19 @@ packages: purls: [] size: 27738 timestamp: 1778268759211 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-16.1.0-he9431aa_1.conda + sha256: e0456b4b49e8f9f9ffc04b1b412101ea2c38476eaceb9a0e4e16792d7cfdd929 + md5: e4489d8717b51cee8a33f2b66d10fa6a + depends: + - libgcc 16.1.0 h205dda4_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libgcc + size: 28123 + timestamp: 1785374523851 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_18.conda sha256: 7dcd7dff2505d56fd5272a6e712ec912f50a46bf07dc6873a7e853694304e6e4 md5: 41f261f5e4e2e8cbd236c2f1f15dae1b @@ -11019,6 +11565,7 @@ packages: - libglvnd 1.7.0 hd24410f_2 - libglx 1.7.0 hd24410f_2 license: LicenseRef-libglvnd + purls: [] size: 145442 timestamp: 1731331005019 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_3.conda @@ -11062,6 +11609,7 @@ packages: constrains: - glib 2.86.4 *_1 license: LGPL-2.1-or-later + purls: [] size: 4512186 timestamp: 1771863220969 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.88.1-h96a7f82_2.conda @@ -11083,6 +11631,7 @@ packages: sha256: 57ec3898a923d4bcc064669e90e8abfc4d1d945a13639470ba5f3748bd3090da md5: 9e115653741810778c9a915a2f8439e7 license: LicenseRef-libglvnd + purls: [] size: 152135 timestamp: 1731330986070 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_3.conda @@ -11099,6 +11648,7 @@ packages: - libglvnd 1.7.0 hd24410f_2 - xorg-libx11 >=1.8.9,<2.0a0 license: LicenseRef-libglvnd + purls: [] size: 77736 timestamp: 1731330998960 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_3.conda @@ -11151,6 +11701,17 @@ packages: - _openmp_mutex >=4.5 size: 587387 timestamp: 1778268674393 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + sha256: 1c609a4a72597350317b92c4d9dfb85d21740219048e2b1d458925a6ccfa3d7a + md5: 4c9b02fc9fe27704777e260157003653 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - _openmp_mutex >=4.5 + size: 617180 + timestamp: 1785374444877 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.12.2-default_ha470c98_1000.conda sha256: e87cf64d87c7706403507df7329f5b597c3b487f4c72ef53ef899e38983ea70e md5: c8b05c85ae962a993d9b7d6c9d10571e @@ -11161,6 +11722,7 @@ packages: - libxml2-16 >=2.14.6 license: BSD-3-Clause license_family: BSD + purls: [] size: 2467105 timestamp: 1765103804193 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwloc-2.13.0-default_ha95e27d_1000.conda @@ -11183,6 +11745,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: Apache-2.0 OR BSD-3-Clause + purls: [] size: 1180000 timestamp: 1758894754411 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libhwy-1.4.0-h0626a34_0.conda @@ -11212,6 +11775,7 @@ packages: constrains: - jpeg <0.0.0a license: IJG AND BSD-3-Clause AND Zlib + purls: [] size: 691818 timestamp: 1762094728337 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.4.1-he30d5cf_0.conda @@ -11236,6 +11800,7 @@ packages: - libhwy >=1.3.0,<1.4.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1489440 timestamp: 1770801995062 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjxl-0.11.2-hbae46ee_1.conda @@ -11264,6 +11829,7 @@ packages: - libcblas 3.11.0 5*_openblas license: BSD-3-Clause license_family: BSD + purls: [] size: 18392 timestamp: 1765818627104 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.11.0-6_h88aeb00_openblas.conda @@ -11411,6 +11977,7 @@ packages: - libgcc >=14 - libstdcxx >=14 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 30323952 timestamp: 1760723774770 @@ -11437,6 +12004,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libnvptxcompiler-dev_linux-aarch64 12.9.86 h579c4fd_2 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27138 timestamp: 1753975408006 @@ -11479,6 +12047,7 @@ packages: - openblas >=0.3.30,<0.3.31.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 4959359 timestamp: 1763114173544 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.32-pthreads_h9d3fd7e_0.conda @@ -11519,6 +12088,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 5742222 timestamp: 1772721263739 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-2026.2.0-h1915271_0.conda @@ -11545,6 +12115,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 10237615 timestamp: 1772721303162 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-arm-cpu-plugin-2026.2.0-h1915271_0.conda @@ -11571,6 +12142,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 111064 timestamp: 1772721336786 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-auto-batch-plugin-2026.2.0-h3d5001d_0.conda @@ -11596,6 +12168,7 @@ packages: - tbb >=2022.3.0 license: Apache-2.0 license_family: APACHE + purls: [] size: 236010 timestamp: 1772721351244 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-auto-plugin-2026.2.0-h3d5001d_0.conda @@ -11621,6 +12194,7 @@ packages: - pugixml >=1.15,<1.16.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 202574 timestamp: 1772721365749 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-hetero-plugin-2026.2.0-he07c6df_0.conda @@ -11646,6 +12220,7 @@ packages: - pugixml >=1.15,<1.16.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 185648 timestamp: 1772721380070 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-ir-frontend-2026.2.0-he07c6df_0.conda @@ -11673,6 +12248,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 1665115 timestamp: 1772721394860 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-onnx-frontend-2026.2.0-h558496d_0.conda @@ -11702,6 +12278,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 631754 timestamp: 1772721411589 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-paddle-frontend-2026.2.0-h558496d_0.conda @@ -11728,6 +12305,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 1091266 timestamp: 1772721428223 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-pytorch-frontend-2026.2.0-hfae3067_0.conda @@ -11755,6 +12333,7 @@ packages: - snappy >=1.2.2,<1.3.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 1184078 timestamp: 1772721443833 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-tensorflow-frontend-2026.2.0-h2cb6e3c_0.conda @@ -11782,6 +12361,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 428895 timestamp: 1772721459028 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenvino-tensorflow-lite-frontend-2026.2.0-hfae3067_0.conda @@ -11813,6 +12393,7 @@ packages: - libgcc >=13 license: MIT license_family: MIT + purls: [] size: 29512 timestamp: 1749901899881 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpciaccess-0.19-he30d5cf_0.conda @@ -11846,6 +12427,7 @@ packages: - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 340156 timestamp: 1770691477245 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpng-1.6.58-h1abf092_0.conda @@ -11869,6 +12451,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 3465308 timestamp: 1769748410724 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.33.5-h306233d_1.conda @@ -11898,6 +12481,7 @@ packages: constrains: - __glibc >=2.17 license: LGPL-2.1-or-later + purls: [] size: 4016799 timestamp: 1771406266442 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/librsvg-2.62.3-hf685517_0.conda @@ -11927,6 +12511,7 @@ packages: - libstdcxx >=14.3.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 7526147 timestamp: 1771377792671 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_18.conda @@ -11937,6 +12522,7 @@ packages: - libstdcxx >=15.2.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 7164557 timestamp: 1771378185265 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda @@ -11952,6 +12538,19 @@ packages: - libsanitizer 15.2.0 size: 7067965 timestamp: 1778268796086 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-16.1.0-h2510bd8_1.conda + sha256: 3dfccbcd3bf34923df7482df41bcdbe599675f2de6f03a554dbc238476693854 + md5: ae3d9771453f2ec660dd79e5728129b3 + depends: + - libgcc >=16.1.0 + - libstdcxx >=16.1.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: + weak: + - libsanitizer 16.1.0 + size: 8123895 + timestamp: 1785374560390 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsndfile-1.2.2-h30591a0_2.conda sha256: f0b6844c09cdec608ca504bd97c5d64a5596a25f66ad806381f9d63dfc89e432 md5: 362bc94148039b77c6a42b1f7e7ef537 @@ -12013,6 +12612,18 @@ packages: - libsqlite >=3.53.3,<4.0a0 size: 968420 timestamp: 1782519054102 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + sha256: da46b52f6815e9771f4e21e3332c423c88644e91ac96b0534e85158adc88a8b4 + md5: 99898219505ff142be5734dc6fa0d900 + depends: + - libgcc >=14 + - libzlib >=1.3.2,<2.0a0 + license: blessing + run_exports: + weak: + - libsqlite >=3.53.4,<4.0a0 + size: 963888 + timestamp: 1785016056926 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_18.conda sha256: 31fdb9ffafad106a213192d8319b9f810e05abca9c5436b60e507afb35a6bc40 md5: f56573d05e3b735cb03efeb64a15f388 @@ -12038,6 +12649,19 @@ packages: run_exports: {} size: 5546559 timestamp: 1778268777463 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + sha256: 81ef9a10a0e01ffc7e03d429ed048410153411b2d8bbf95c334bdf3dcf175ab0 + md5: 0bfd287b881e05351a01c7ebf7bf8f1b + depends: + - libgcc 16.1.0 h205dda4_1 + constrains: + - libstdcxx-ng ==16.1.0=*_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 6255794 + timestamp: 1785374543663 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_18.conda sha256: 035a31cde134e706e30029a837a31f729ad32b7c5bca023271dfe91a8ba6c896 md5: 699d294376fe18d80b7ce7876c3a875d @@ -12057,6 +12681,19 @@ packages: purls: [] size: 27803 timestamp: 1778268813278 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-16.1.0-hdbbeba8_1.conda + sha256: cb88eb500022e01f835209e771d455d2296e10a18a749f518c257dfcab7d46ba + md5: a728408241f9db99bad0d1642c908714 + depends: + - libstdcxx 16.1.0 hef695bb_1 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libstdcxx + size: 28182 + timestamp: 1785374577436 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.10-hf9559e3_4.conda sha256: 95bb4c430e8ca666a4c67b7951f03fbee5a5258b1d29c2a26bf56c86fe32c010 md5: 96e731e9cf876fb2d8882093c0f24630 @@ -12064,6 +12701,7 @@ packages: - libcap >=2.77,<2.78.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 517911 timestamp: 1770738680829 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hf9559e3_0.conda @@ -12158,6 +12796,7 @@ packages: - libcap >=2.77,<2.78.0a0 - libgcc >=14 license: LGPL-2.1-or-later + purls: [] size: 157130 timestamp: 1770738690431 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hf9559e3_0.conda @@ -12220,6 +12859,7 @@ packages: - libgcc >=14 license: BSD-3-Clause license_family: BSD + purls: [] size: 43453 timestamp: 1766271546875 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42-h1022ec0_0.conda @@ -12350,6 +12990,7 @@ packages: - xorg-libxau >=1.0.12,<2.0a0 license: MIT/X11 Derivative license_family: MIT + purls: [] size: 863646 timestamp: 1764794352540 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxkbcommon-1.13.2-h3c6a4c8_0.conda @@ -12381,6 +13022,7 @@ packages: - libxml2 2.15.2 license: MIT license_family: MIT + purls: [] size: 598438 timestamp: 1772704671710 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h79dcc73_0.conda @@ -12411,6 +13053,7 @@ packages: - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT + purls: [] size: 47837 timestamp: 1772704681112 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h869d058_0.conda @@ -12437,6 +13080,7 @@ packages: - zlib 1.3.1 *_2 license: Zlib license_family: Other + purls: [] size: 66657 timestamp: 1727963199518 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda @@ -12452,6 +13096,18 @@ packages: - libzlib >=1.3.2,<2.0a0 size: 69833 timestamp: 1774072605429 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda + sha256: 76efa6cc9d7e6f5ee3bbca0939f64054af2bdfb3c3632531f8e633cf6c2ea41e + md5: bd534c2fbe56d8c2ea3b2d8f5e12bca8 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 70108 + timestamp: 1785276540870 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llvm-openmp-22.1.0-he40846f_0.conda sha256: 08e50e981736118b6cc379096395bd725eeac1cb3852bcdfa1d2980acba39c29 md5: 757e953866f430da9de3fcebf44d1474 @@ -12498,6 +13154,8 @@ packages: - numpy >=1.23,<3 - python_abi 3.14.* *_cp314 license: MPL-2.0 AND Apache-2.0 + purls: + - pkg:pypi/ml-dtypes?source=hash-mapping size: 306998 timestamp: 1771362449472 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mpc-1.3.1-h783934e_1.conda @@ -12597,6 +13255,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 8006259 timestamp: 1770098510476 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.4.3-py314haac167e_0.conda @@ -12692,6 +13352,19 @@ packages: - openssl >=3.6.3,<4.0a0 size: 3704664 timestamp: 1781069675555 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + sha256: c89e748e8a008e8ca6f25e102362f33319db0c98cc29d98ddada92842f636327 + md5: 1600dfde78c5adba306f8571af62a323 + depends: + - ca-certificates + - libgcc >=14 + license: Apache-2.0 + license_family: Apache + run_exports: + weak: + - openssl >=3.6.3,<4.0a0 + size: 3719270 + timestamp: 1785913554920 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/optree-0.19.0-py314hd7d8586_0.conda sha256: 78deba0984ab747179c1aa87f024d6597ecfba75378c9b4601046d9c8ab59956 md5: 214ab44a77f6135a6b0178c1c9cb5149 @@ -12743,6 +13416,7 @@ packages: - libpng >=1.6.49,<1.7.0a0 - libzlib >=1.3.1,<2.0a0 license: LGPL-2.1-or-later + purls: [] size: 468811 timestamp: 1751293869070 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pcre2-10.47-hf841c20_0.conda @@ -12934,28 +13608,59 @@ packages: size: 34900936 timestamp: 1781254861576 python_site_packages_path: lib/python3.14/site-packages -- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pytorch-2.10.0-cuda130_generic_py314_h7cb4a1c_203.conda - sha256: 70b45b24d9591f943ff3a5ffff9419af85293e318a5f001be41cd9538d4e21c9 - md5: eec5f372504eec64c324446bbfc8442a +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda + build_number: 101 + sha256: b8135c10971f387402f42b8fe52cf983665e9af9a7b5c839ae082a0f71f6c0c4 + md5: 6ed1a6d56adc15f18919b6fc87660bd1 depends: - - __cuda - - __glibc >=2.28,<3.0.a0 - - _openmp_mutex * *_llvm - - _openmp_mutex >=4.5 - - arm-variant * sbsa - - cuda-cudart >=13.0.96,<14.0a0 - - cuda-cupti >=13.0.85,<14.0a0 - - cuda-nvrtc >=13.0.88,<14.0a0 - - cuda-nvtx >=13.0.85,<14.0a0 - - cuda-version >=13.0,<14 - - filelock - - fmt >=12.1.0,<12.2.0a0 - - fsspec - - jinja2 - - libabseil * cxx17* - - libabseil >=20260107.1,<20260108.0a0 - - libcblas >=3.9.0,<4.0a0 - - libcublas >=13.1.0.3,<14.0a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-aarch64 >=2.36.1 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - libgcc >=14 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.3,<4.0a0 + - libuuid >=2.42.2,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + run_exports: + weak: + - python_abi 3.14.* *_cp314 + noarch: + - python + size: 34850010 + timestamp: 1784909900639 + python_site_packages_path: lib/python3.14/site-packages +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pytorch-2.10.0-cuda130_generic_py314_h7cb4a1c_203.conda + sha256: 70b45b24d9591f943ff3a5ffff9419af85293e318a5f001be41cd9538d4e21c9 + md5: eec5f372504eec64c324446bbfc8442a + depends: + - __cuda + - __glibc >=2.28,<3.0.a0 + - _openmp_mutex * *_llvm + - _openmp_mutex >=4.5 + - arm-variant * sbsa + - cuda-cudart >=13.0.96,<14.0a0 + - cuda-cupti >=13.0.85,<14.0a0 + - cuda-nvrtc >=13.0.88,<14.0a0 + - cuda-nvtx >=13.0.85,<14.0a0 + - cuda-version >=13.0,<14 + - filelock + - fmt >=12.1.0,<12.2.0a0 + - fsspec + - jinja2 + - libabseil * cxx17* + - libabseil >=20260107.1,<20260108.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcublas >=13.1.0.3,<14.0a0 - libcudnn >=9.19.0.56,<10.0a0 - libcudss >=0.7.1.4,<0.7.2.0a0 - libcufft >=12.0.0.61,<13.0a0 @@ -13202,6 +13907,7 @@ packages: - dbus >=1.16.2,<2.0a0 - xorg-libx11 >=1.8.13,<2.0a0 license: Zlib + purls: [] size: 2136476 timestamp: 1771668207211 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shaderc-2025.5-hfeb5c2c_1.conda @@ -13214,6 +13920,7 @@ packages: - spirv-tools >=2026,<2027.0a0 license: Apache-2.0 license_family: Apache + purls: [] size: 115498 timestamp: 1770208786806 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shaderc-2026.2-hfeb5c2c_0.conda @@ -13261,6 +13968,7 @@ packages: - spirv-headers >=1.4.341.0,<1.4.341.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 2255599 timestamp: 1770089690097 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/spirv-tools-2026.2-hfefdfc9_0.conda @@ -13311,6 +14019,7 @@ packages: - libstdcxx >=14 license: Apache-2.0 license_family: APACHE + purls: [] size: 144746 timestamp: 1767888618836 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tbb-2023.0.0-h57272ed_2.conda @@ -13402,6 +14111,18 @@ packages: run_exports: {} size: 20306087 timestamp: 1784166394558 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda + sha256: 1c3f53ff574ca92562c83e29ab158d0e5790ed3dc0a70bc6c7a6e6108bc5c623 + md5: db4ed0e0968098dd8bdca55d62dc5dc5 + depends: + - libgcc >=14 + - libstdcxx >=14 + constrains: + - __glibc >=2.17 + license: Apache-2.0 OR MIT + run_exports: {} + size: 17181969 + timestamp: 1785973409651 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/wayland-1.24.0-h4f8a99f_1.conda sha256: d94af8f287db764327ac7b48f6c0cd5c40da6ea2606afd34ac30671b7c85d8ee md5: f6966cb1f000c230359ae98c29e37d87 @@ -13412,6 +14133,7 @@ packages: - libstdcxx >=14 license: MIT license_family: MIT + purls: [] size: 331480 timestamp: 1761174368396 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/wayland-1.25.0-h4f8a99f_0.conda @@ -13467,6 +14189,7 @@ packages: - xorg-libx11 >=1.8.13,<2.0a0 license: MIT license_family: MIT + purls: [] size: 399629 timestamp: 1772021320967 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libice-1.1.2-h86ecc28_0.conda @@ -13567,6 +14290,7 @@ packages: - xorg-libxfixes >=6.0.1,<7.0a0 license: MIT license_family: MIT + purls: [] size: 48197 timestamp: 1727801059062 - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxi-1.8.3-he30d5cf_0.conda @@ -13893,6 +14617,24 @@ packages: run_exports: {} size: 128866 timestamp: 1781708962055 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda + sha256: 95e8e74062a5fe5f870ac8c90302b6e89945165fdaed7810606e84ddee6aac12 + md5: e27d2ac27b096dc51fedfcf775a53f9b + depends: + - __win + license: ISC + run_exports: {} + size: 132136 + timestamp: 1784754918886 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + sha256: 0a0544cf95f64394fe4959286f5c71f5444ad58feb0602e53becb27448d24da6 + md5: 0f51e2391ade309db462a55611263e9c + depends: + - __unix + license: ISC + run_exports: {} + size: 131780 + timestamp: 1784754889428 - conda: https://conda.anaconda.org/conda-forge/noarch/cachecontrol-0.14.3-pyha770c72_0.conda sha256: ec791bb6f1ef504411f87b28946a7ae63ed1f3681cefc462cf1dfdaf0790b6a9 md5: 241ef6e3db47a143ac34c21bfba510f1 @@ -13962,6 +14704,8 @@ packages: - python license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/cloudpickle?source=hash-mapping size: 27353 timestamp: 1765303462831 - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda @@ -14016,6 +14760,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1150650 timestamp: 1746189825236 @@ -14025,6 +14770,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 1472271 timestamp: 1779895496841 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_0.conda @@ -14036,6 +14782,15 @@ packages: run_exports: {} size: 1475805 timestamp: 1782773759292 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_1.conda + sha256: fa44586fc308d0089fb5f014d5b53cbea19a2e83cd7bbd1e19c79140293be9a3 + md5: 199a317645eac1a18745d05dc551ab6e + depends: + - cuda-version >=13.3,<13.4.0a0 + license: LicenseRef-NVIDIA-End-User-License-Agreement + run_exports: {} + size: 1486700 + timestamp: 1785874560026 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-12.9.27-h579c4fd_0.conda sha256: b4efaee8fa95b9ec97a462dc343914a138ece704895e33caa52ac55968f7adfa md5: 71e4d87a72bf003bd05f05a502288b2a @@ -14043,6 +14798,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1149299 timestamp: 1746189919921 @@ -14053,6 +14809,7 @@ packages: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 1481900 timestamp: 1779895522474 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_0.conda @@ -14065,12 +14822,23 @@ packages: run_exports: {} size: 1480995 timestamp: 1782773779842 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_1.conda + sha256: 0b5f21da410f288503f4f9b97b0d4bbec670c25dbf2317b6a92703fbe1a8b91a + md5: 23397299679c728e710be12875f64857 + depends: + - arm-variant * sbsa + - cuda-version >=13.3,<13.4.0a0 + license: LicenseRef-NVIDIA-End-User-License-Agreement + run_exports: {} + size: 1479144 + timestamp: 1785874588629 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-12.9.27-h57928b3_0.conda sha256: 681eb1d9afd596e04329a82b04734c0e37c6ecb94b3380f3a378d61983e2a8cc md5: 8f897dca7111f3bb4ded97ba6947b186 depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1139649 timestamp: 1746189858434 @@ -14080,6 +14848,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 1462453 timestamp: 1779895589763 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_0.conda @@ -14091,12 +14860,22 @@ packages: run_exports: {} size: 1467923 timestamp: 1782773832153 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_1.conda + sha256: 57729383a520a75b1373c6795cd412e76f3799105e3240b258d33fbcc2d598e5 + md5: 6c36b47ed939964651d102a179699d1d + depends: + - cuda-version >=13.3,<13.4.0a0 + license: LicenseRef-NVIDIA-End-User-License-Agreement + run_exports: {} + size: 1476948 + timestamp: 1785874646188 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.9.86-ha770c72_2.conda sha256: e6257534c4b4b6b8a1192f84191c34906ab9968c92680fa09f639e7846a87304 md5: 79d280de61e18010df5997daea4743df depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 94239 timestamp: 1753975242354 @@ -14106,6 +14885,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 116655 timestamp: 1779905079263 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda @@ -14124,6 +14904,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 94794 timestamp: 1753975199249 @@ -14134,6 +14915,7 @@ packages: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 116665 timestamp: 1779905122757 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda @@ -14152,6 +14934,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 95452 timestamp: 1753975640812 @@ -14161,6 +14944,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] size: 117452 timestamp: 1779905164275 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-13.3.73-h57928b3_0.conda @@ -14181,6 +14965,7 @@ packages: - cuda-cudart_linux-64 - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -14195,6 +14980,7 @@ packages: - cuda-cudart_linux-64 - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=13.3.29,<14.0a0 @@ -14210,6 +14996,7 @@ packages: - cuda-cudart_linux-aarch64 - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -14225,6 +15012,7 @@ packages: - cuda-cudart_linux-aarch64 - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=13.3.29,<14.0a0 @@ -14239,6 +15027,7 @@ packages: - cuda-cudart_win-64 - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -14253,6 +15042,7 @@ packages: - cuda-cudart_win-64 - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1548117 timestamp: 1779898493787 @@ -14262,6 +15052,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1148889 timestamp: 1749218381225 @@ -14271,6 +15062,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1126340 timestamp: 1779898412056 @@ -14281,6 +15073,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1152498 timestamp: 1749218333554 @@ -14291,6 +15084,7 @@ packages: - arm-variant * sbsa - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 1133087 timestamp: 1779898428591 @@ -14300,6 +15094,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 354611 timestamp: 1749218544740 @@ -14309,6 +15104,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 83026 timestamp: 1779898478182 @@ -14318,6 +15114,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 197249 timestamp: 1749218394213 @@ -14338,6 +15135,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 212993 timestamp: 1749218341193 @@ -14358,6 +15156,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23260 timestamp: 1749218569458 @@ -14367,6 +15166,7 @@ packages: depends: - cuda-version >=13.3,<13.4.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 24659 timestamp: 1779898481919 @@ -14382,6 +15182,7 @@ packages: constrains: - gcc_impl_linux-64 >=6,<15.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 28121 timestamp: 1753975535813 @@ -14398,6 +15199,7 @@ packages: constrains: - gcc_impl_linux-aarch64 >=6,<15.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 28252 timestamp: 1753975422031 @@ -14410,6 +15212,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libnvptxcompiler-dev_win-64 12.9.86 h57928b3_2 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23452957 timestamp: 1753976361068 @@ -14419,6 +15222,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27096 timestamp: 1753975261562 @@ -14447,6 +15251,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27218 timestamp: 1753975206503 @@ -14476,6 +15281,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27284 timestamp: 1753975714790 @@ -14506,6 +15312,8 @@ packages: - python license: Apache-2.0 license_family: APACHE + purls: + - pkg:pypi/cuda-pathfinder?source=hash-mapping size: 41835 timestamp: 1773187684373 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda @@ -14520,6 +15328,18 @@ packages: run_exports: {} size: 45350 timestamp: 1782782777927 +- conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.6.0-pyhc364b38_0.conda + sha256: a949bc139e9bc53d9d6dd0fe18b587f3ed49e870fe5994c7b6ae424d698f00cd + md5: d154eea5563eb45f05031ef90fed6518 + depends: + - python >=3.10 + - cuda-version >=12.0,<14 + - python + license: Apache-2.0 + license_family: APACHE + run_exports: {} + size: 46398 + timestamp: 1784649204190 - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda sha256: 5f5f428031933f117ff9f7fcc650e6ea1b3fef5936cf84aa24af79167513b656 md5: b6d5d7f1c171cbd228ea06b556cfa859 @@ -14527,6 +15347,7 @@ packages: - cudatoolkit 12.9|12.9.* - __cuda >=12 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 21578 timestamp: 1746134436166 @@ -14583,6 +15404,8 @@ packages: - python license: LGPL-3.0-only license_family: LGPL + purls: + - pkg:pypi/docutils?source=hash-mapping run_exports: {} size: 459540 timestamp: 1779967837277 @@ -14793,6 +15616,8 @@ packages: - python license: Apache-2.0 license_family: APACHE + purls: + - pkg:pypi/importlib-metadata?source=hash-mapping size: 34641 timestamp: 1747934053147 - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda @@ -15086,6 +15911,7 @@ packages: - sysroot_linux-64 ==2.28 license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL + purls: [] run_exports: {} size: 1278712 timestamp: 1765578681495 @@ -15096,6 +15922,7 @@ packages: - sysroot_linux-aarch64 ==2.28 license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL + purls: [] run_exports: {} size: 1248134 timestamp: 1765578613607 @@ -15106,6 +15933,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 3084533 timestamp: 1771377786730 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_118.conda @@ -15115,6 +15943,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 3085932 timestamp: 1771378098166 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_119.conda @@ -15127,6 +15956,16 @@ packages: run_exports: {} size: 3095909 timestamp: 1778268932148 +- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-16.1.0-h59071f9_101.conda + sha256: b314251d957b16c71ec241119ac09b9530c5c4ce140026ec98d297f55d6c5e08 + md5: 19b0151ecb1d122f706ebd2f82f9a017 + depends: + - __unix + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 3096495 + timestamp: 1785375361053 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-14.3.0-h25ba3ff_118.conda sha256: 058fab0156cb13897f7e4a2fc9d63c922d3de09b6429390365f91b62f1dddb0e md5: 3733752e5a7a0737c8c4f1897f2074f9 @@ -15134,6 +15973,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 2335839 timestamp: 1771377646960 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_118.conda @@ -15143,6 +15983,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 2364690 timestamp: 1771378032404 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda @@ -15155,6 +15996,16 @@ packages: run_exports: {} size: 2353893 timestamp: 1778268665954 +- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-16.1.0-hd673532_101.conda + sha256: 885f0d8a47f7ea50d7b33d07a240f2301935602b9d2a39a35b5018b13e934100 + md5: 00cdfad75c8331e103f830fb17184da1 + depends: + - __unix + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 2357226 + timestamp: 1785374433650 - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_win-64-15.2.0-hbb59886_118.conda sha256: e43ffa48a88a7d77a0dc0d3ccfa3acc55702e9d964e8564e86927f5a389a6c51 md5: 1e020780767f809769807a442f5d6f6a @@ -15162,6 +16013,7 @@ packages: - m2-conda-epoch license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 2422242 timestamp: 1771382108271 - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_linux-64-12.9.86-ha770c72_2.conda @@ -15170,6 +16022,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 14422867 timestamp: 1753975387297 @@ -15180,6 +16033,7 @@ packages: - arm-variant * sbsa - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 13939480 timestamp: 1753975314178 @@ -15189,6 +16043,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 31818844 timestamp: 1753976049670 @@ -15199,6 +16054,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 20171098 timestamp: 1771377827750 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.2.0-hd446a21_118.conda @@ -15208,6 +16064,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 20669511 timestamp: 1771378139786 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.2.0-hd446a21_119.conda @@ -15220,6 +16077,16 @@ packages: run_exports: {} size: 20765069 timestamp: 1778268963689 +- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-16.1.0-h41cdd0d_101.conda + sha256: c1521172f2fdf5510d79b621ea835064209fe3131518e0d8b2b43362a75e7b4c + md5: 8593636203272a748b63d56cbd674753 + depends: + - __unix + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 22519609 + timestamp: 1785375386152 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-14.3.0-h57c8d61_118.conda sha256: 609585a02b05a2b0f2cabb18849328455cbce576f2e3eb8108f3ef7f4cb165a6 md5: bcf29f2ed914259a258204b05346abb1 @@ -15227,6 +16094,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 17565700 timestamp: 1771377672552 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_118.conda @@ -15236,6 +16104,7 @@ packages: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 17628403 timestamp: 1771378058765 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda @@ -15248,6 +16117,16 @@ packages: run_exports: {} size: 17627362 timestamp: 1778268687968 +- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-16.1.0-h2445e1f_101.conda + sha256: 926d2c2dedfca7334804d5c8a0727a3746ef580be8763f51ccc2ece24c7be56c + md5: d2cd8c4b92b4e6dbcb2616d855107aca + depends: + - __unix + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 19792513 + timestamp: 1785374457502 - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_win-64-15.2.0-h0a72980_118.conda sha256: 0b27331f127c6c10017442cc98c483aa868298102e98aae70ad86b9a5ae0029e md5: b7a331c07d140e476fee0c70c9696e87 @@ -15255,6 +16134,7 @@ packages: - m2-conda-epoch license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 11729036 timestamp: 1771382135681 - conda: https://conda.anaconda.org/conda-forge/noarch/m2w64-sysroot_win-64-12.0.0.r4.gg4f2fc60ca-hd8ed1ab_10.conda @@ -15267,6 +16147,7 @@ packages: - mingw-w64-ucrt-x86_64-windows-default-manifest - mingw-w64-ucrt-x86_64-winpthreads-git 12.0.0.r4.gg4f2fc60ca hd8ed1ab_10 - ucrt + purls: [] size: 8421 timestamp: 1759768559974 - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.0.0-pyhd8ed1ab_0.conda @@ -15325,6 +16206,7 @@ packages: constrains: - mingw-w64-ucrt-x86_64-winpthreads-git 12.0.0.r4.gg4f2fc60ca.* license: ZPL-2.1 + purls: [] size: 5663635 timestamp: 1759768458961 - conda: https://conda.anaconda.org/conda-forge/noarch/mingw-w64-ucrt-x86_64-headers-git-12.0.0.r4.gg4f2fc60ca-hd8ed1ab_10.conda @@ -15336,6 +16218,7 @@ packages: - mingw-w64-ucrt-x86_64-crt-git 12.0.0.r4.gg4f2fc60ca.* - mingw-w64-ucrt-x86_64-winpthreads-git 12.0.0.r4.gg4f2fc60ca.* license: ZPL-2.1 AND LGPL-2.1-or-later + purls: [] size: 7089846 timestamp: 1759768412123 - conda: https://conda.anaconda.org/conda-forge/noarch/mingw-w64-ucrt-x86_64-windows-default-manifest-6.4-he206cdd_7.conda @@ -15346,6 +16229,7 @@ packages: constrains: - m2w64-sysroot_win-64 >=12.0.0.r0 license: FSFAP + purls: [] size: 7412 timestamp: 1717486007140 - conda: https://conda.anaconda.org/conda-forge/noarch/mingw-w64-ucrt-x86_64-winpthreads-git-12.0.0.r4.gg4f2fc60ca-hd8ed1ab_10.conda @@ -15357,6 +16241,7 @@ packages: constrains: - mingw-w64-ucrt-x86_64-crt-git 12.0.0.r4.gg4f2fc60ca.* license: MIT AND BSD-3-Clause-Clear + purls: [] size: 123916 timestamp: 1759768539535 - conda: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.1-pyhcf101f3_0.conda @@ -15530,7 +16415,7 @@ packages: license: Apache-2.0 license_family: APACHE purls: - - pkg:pypi/packaging?source=compressed-mapping + - pkg:pypi/packaging?source=hash-mapping size: 72010 timestamp: 1769093650580 - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda @@ -15544,6 +16429,16 @@ packages: run_exports: {} size: 91574 timestamp: 1777103621679 +- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + sha256: c432626b16768b8dab228bfb706f7060c2d462a21c516d240f68f2f902b5a044 + md5: 936687ed80f295a1f5dbcf8bd34c252c + depends: + - python >=3.9 + - python + license: Apache-2.0 + run_exports: {} + size: 116363 + timestamp: 1785888127370 - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.6-pyhcf101f3_0.conda sha256: 42b2d77ccea60752f3aa929a6413a7835aaacdbbde679f2f5870a744fa836b94 md5: 97c1ce2fffa1209e7afb432810ec6e12 @@ -15644,6 +16539,8 @@ packages: - python >=3.9 license: MIT license_family: MIT + purls: + - pkg:pypi/py-cpuinfo?source=hash-mapping size: 25766 timestamp: 1733236452235 - conda: https://conda.anaconda.org/conda-forge/noarch/pybind11-3.0.1-pyh7a1b43c_0.conda @@ -15729,6 +16626,8 @@ packages: - python >=3.10 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/pyglet?source=hash-mapping size: 725938 timestamp: 1770169149613 - conda: https://conda.anaconda.org/conda-forge/noarch/pyglet-2.1.14-pyhd8ed1ab_0.conda @@ -15751,6 +16650,8 @@ packages: - python >=3.9 license: BSD-2-Clause license_family: BSD + purls: + - pkg:pypi/pygments?source=hash-mapping size: 889287 timestamp: 1750615908735 - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda @@ -15831,6 +16732,8 @@ packages: - python >=3.10 license: BSD-2-Clause license_family: BSD + purls: + - pkg:pypi/pytest-benchmark?source=hash-mapping size: 43976 timestamp: 1762716480208 - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-randomly-3.15.0-pyhd8ed1ab_0.conda @@ -15842,6 +16745,8 @@ packages: - python >=3.6 license: MIT license_family: MIT + purls: + - pkg:pypi/pytest-randomly?source=hash-mapping size: 14133 timestamp: 1692131735622 - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-repeat-0.9.4-pyhd8ed1ab_0.conda @@ -15852,6 +16757,8 @@ packages: - python >=3.9 license: MPL-2.0 license_family: MOZILLA + purls: + - pkg:pypi/pytest-repeat?source=hash-mapping size: 10537 timestamp: 1744061283541 - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-rerunfailures-16.1-pyhd8ed1ab_0.conda @@ -15863,6 +16770,8 @@ packages: - python >=3.10 license: MPL-2.0 license_family: OTHER + purls: + - pkg:pypi/pytest-rerunfailures?source=hash-mapping size: 19613 timestamp: 1760091441792 - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda @@ -15987,6 +16896,8 @@ packages: - python >=3.10 license: MIT license_family: MIT + purls: + - pkg:pypi/setuptools?source=hash-mapping size: 639697 timestamp: 1773074868565 - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda @@ -16015,6 +16926,22 @@ packages: run_exports: {} size: 28577 timestamp: 1782401906421 +- conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + sha256: 8eb9daf6fc70111abf73f848c6d32d2769aa1fba550f793b865076fd4e33fb3a + md5: eefa3bc61c9224107d3a9afeb37552a9 + depends: + - python >=3.10 + - vcs_versioning >=2.0.0.dev0 + - packaging >=20 + - setuptools + - tomli >=1 + - typing_extensions + - python + license: MIT + license_family: MIT + run_exports: {} + size: 29407 + timestamp: 1784653562396 - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda sha256: 458227f759d5e3fcec5d9b7acce54e10c9e1f4f4b7ec978f3bfd54ce4ee9853d md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -16277,6 +17204,7 @@ packages: - tzdata license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL + purls: [] run_exports: strong: - __glibc >=2.28,<3.0.a0 @@ -16291,6 +17219,7 @@ packages: - tzdata license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL + purls: [] run_exports: strong: - __glibc >=2.28,<3.0.a0 @@ -16316,6 +17245,8 @@ packages: - python license: MIT license_family: MIT + purls: + - pkg:pypi/tomli?source=hash-mapping size: 21453 timestamp: 1768146676791 - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda @@ -16431,6 +17362,20 @@ packages: run_exports: {} size: 83180 timestamp: 1782748145197 +- conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + sha256: 179dd4ed561926e5ab95934009bb4359487264de149b5274e43e9e094900dfe4 + md5: 3a8fb54b1dc8fbfdeb51083a1143edd1 + depends: + - python >=3.10 + - packaging >=26.2 + - tomli >=1 + - typing_extensions >=4.1 + - python + license: MIT + license_family: MIT + run_exports: {} + size: 83586 + timestamp: 1785306846938 - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda sha256: b72270395326dc56de9bd6ca82f63791b3c8c9e2b98e25242a9869a4ca821895 md5: f622897afff347b715d046178ad745a5 @@ -16446,6 +17391,7 @@ packages: md5: 7da1571f560d4ba3343f7f4c48a79c76 license: MIT license_family: MIT + purls: [] size: 140476 timestamp: 1765821981856 - conda: https://conda.anaconda.org/conda-forge/noarch/wayland-protocols-1.49-hd8ed1ab_0.conda @@ -16513,6 +17459,7 @@ packages: - msys2-conda-epoch <0.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 52252 timestamp: 1770943776666 - conda: https://conda.anaconda.org/conda-forge/win-64/aom-3.14.1-pl5321h06fc181_1.conda @@ -16536,6 +17483,7 @@ packages: - vc14_runtime >=14.29.30139 license: BSD-2-Clause license_family: BSD + purls: [] size: 1958151 timestamp: 1718551737234 - conda: https://conda.anaconda.org/conda-forge/win-64/binutils_impl_win-64-2.45.1-default_ha84baeb_101.conda @@ -16547,6 +17495,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: GPL-3.0-only license_family: GPL + purls: [] size: 5830940 timestamp: 1770267725685 - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.2.0-py314he701e3d_1.conda @@ -16566,6 +17515,20 @@ packages: - pkg:pypi/brotli?source=hash-mapping size: 335782 timestamp: 1764018443683 +- conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda + sha256: 04767466ee9227c9c57ab2c6503e0149177d34111c7418d2f420297acb1eb229 + md5: c3301c058362f340100d91cd8be0393f + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: bzip2-1.0.6 + license_family: BSD + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 55919 + timestamp: 1785906343696 - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda sha256: 76dfb71df5e8d1c4eded2dbb5ba15bb8fb2e2b0fe42d94145d5eed4c75c35902 md5: 4cb8e6b48f67de0b018719cdf1136306 @@ -16623,6 +17586,7 @@ packages: - gcc_impl_win-64 >=15.2.0,<15.2.1.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 54725 timestamp: 1771382417485 - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-12.9.6-py314hdc4d7ff_0.conda @@ -16643,6 +17607,8 @@ packages: - cuda-python >=12.9.6,<12.10.0a0 - cuda-cudart >=12,<13.0a0 license: LicenseRef-NVIDIA-SOFTWARE-LICENSE + purls: + - pkg:pypi/cuda-bindings?source=hash-mapping size: 3891535 timestamp: 1773288261512 - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-12.9.7-py314h2547b3f_1.conda @@ -16693,6 +17659,7 @@ packages: depends: - cuda-version >=12.9,<12.10.0a0 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 29604 timestamp: 1753975679251 @@ -16706,6 +17673,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 170799 timestamp: 1749218946117 @@ -16734,6 +17702,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-cudart >=12.9.79,<13.0a0 @@ -16764,6 +17733,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 23249 timestamp: 1749218998822 @@ -16794,6 +17764,7 @@ packages: constrains: - vc >=14.2 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27684 timestamp: 1753976469818 @@ -16808,6 +17779,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27361 timestamp: 1753976245101 @@ -16820,6 +17792,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 58467504 timestamp: 1760723834711 @@ -16846,6 +17819,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-nvrtc >=12.9.86,<13.0a0 @@ -16861,6 +17835,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: weak: - cuda-nvrtc >=13.3.33,<14.0a0 @@ -16897,6 +17872,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 31168 timestamp: 1753975780038 @@ -16933,6 +17909,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 40286977 timestamp: 1753975898550 @@ -17064,6 +18041,7 @@ packages: - __cuda >=12.8 license: GPL-2.0-or-later license_family: GPL + purls: [] size: 10417843 timestamp: 1773010275486 - conda: https://conda.anaconda.org/conda-forge/win-64/ffmpeg-8.1.1-gpl_h6d5d71d_904.conda @@ -17164,6 +18142,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 195332 timestamp: 1771382820659 - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.18.1-hd47e2ca_0.conda @@ -17191,6 +18170,7 @@ packages: - libfreetype 2.14.2 h57928b3_0 - libfreetype6 2.14.2 hdbac1cb_0 license: GPL-2.0-only OR FTL + purls: [] size: 185633 timestamp: 1772756186241 - conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.3-h57928b3_1.conda @@ -17223,6 +18203,7 @@ packages: - gcc_impl_win-64 15.2.0 ha526d7c_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 1198343 timestamp: 1771382604468 - conda: https://conda.anaconda.org/conda-forge/win-64/gcc_impl_win-64-15.2.0-ha526d7c_18.conda @@ -17238,6 +18219,7 @@ packages: - m2w64-sysroot_win-64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 62510234 timestamp: 1771382289787 - conda: https://conda.anaconda.org/conda-forge/win-64/gdk-pixbuf-2.44.5-h1f5b9c4_1.conda @@ -17255,6 +18237,7 @@ packages: - vc14_runtime >=14.44.35208 license: LGPL-2.1-or-later license_family: LGPL + purls: [] size: 574950 timestamp: 1771530717329 - conda: https://conda.anaconda.org/conda-forge/win-64/gdk-pixbuf-2.44.6-h1f5b9c4_0.conda @@ -17285,6 +18268,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD + purls: [] size: 4929181 timestamp: 1770195251565 - conda: https://conda.anaconda.org/conda-forge/win-64/glslang-16.3.0-h294ba9c_0.conda @@ -17309,6 +18293,7 @@ packages: - vc14_runtime >=14.44.35208 license: LGPL-2.0-or-later license_family: LGPL + purls: [] size: 96336 timestamp: 1755102441729 - conda: https://conda.anaconda.org/conda-forge/win-64/graphite2-1.3.15-hac47afa_0.conda @@ -17346,6 +18331,7 @@ packages: - gxx_impl_win-64 15.2.0 h22fd5bf_18 license: BSD-3-Clause license_family: BSD + purls: [] size: 824078 timestamp: 1771382638258 - conda: https://conda.anaconda.org/conda-forge/win-64/gxx_impl_win-64-15.2.0-h22fd5bf_18.conda @@ -17358,6 +18344,7 @@ packages: - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 14533744 timestamp: 1771382555150 - conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-13.1.0-h5a1b470_0.conda @@ -17377,6 +18364,7 @@ packages: - vc14_runtime >=14.29.30139 license: MIT license_family: MIT + purls: [] size: 1285640 timestamp: 1773217788574 - conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-14.2.1-h5a1b470_0.conda @@ -17408,6 +18396,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 13222158 timestamp: 1767970128854 - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.3-h637d24d_0.conda @@ -17456,6 +18445,7 @@ packages: - binutils_impl_win-64 2.45.1 license: GPL-3.0-only license_family: GPL + purls: [] size: 876736 timestamp: 1770267709635 - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda @@ -17483,6 +18473,7 @@ packages: - liblapacke 3.11.0 5*_mkl license: BSD-3-Clause license_family: BSD + purls: [] size: 67438 timestamp: 1765819100043 - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-6_hf2e6a31_mkl.conda @@ -17567,6 +18558,7 @@ packages: - blas 2.305 mkl license: BSD-3-Clause license_family: BSD + purls: [] size: 68079 timestamp: 1765819124349 - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-6_h2a3cdd5_mkl.conda @@ -17622,6 +18614,7 @@ packages: - expat 2.7.4.* license: MIT license_family: MIT + purls: [] size: 70323 timestamp: 1771259521393 - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.5-hac47afa_0.conda @@ -17674,6 +18667,7 @@ packages: depends: - libfreetype6 >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 8404 timestamp: 1772756167212 - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.3-h57928b3_1.conda @@ -17697,6 +18691,7 @@ packages: constrains: - freetype >=2.14.2 license: GPL-2.0-only OR FTL + purls: [] size: 340155 timestamp: 1772756166648 - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.3-hdbac1cb_1.conda @@ -17726,6 +18721,7 @@ packages: - libgomp 15.2.0 h8ee18e1_18 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 820022 timestamp: 1771382190160 - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.4-h0c9aed9_1.conda @@ -17743,6 +18739,7 @@ packages: constrains: - glib 2.86.4 *_1 license: LGPL-2.1-or-later + purls: [] size: 4095369 timestamp: 1771863229701 - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.88.1-h7ce1215_2.conda @@ -17772,6 +18769,7 @@ packages: - msys2-conda-epoch <0.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 663864 timestamp: 1771382118742 - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.2-default_h4379cf1_1000.conda @@ -17812,6 +18810,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: Apache-2.0 OR BSD-3-Clause + purls: [] size: 536186 timestamp: 1758894243956 - conda: https://conda.anaconda.org/conda-forge/win-64/libhwy-1.4.0-h172a326_0.conda @@ -17855,6 +18854,7 @@ packages: constrains: - jpeg <0.0.0a license: IJG AND BSD-3-Clause AND Zlib + purls: [] size: 841783 timestamp: 1762094814336 - conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.1.4.1-hfd05255_0.conda @@ -17897,6 +18897,7 @@ packages: - libhwy >=1.3.0,<1.4.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 1317916 timestamp: 1770801992810 - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-5_hf9ab0e9_mkl.conda @@ -17911,6 +18912,7 @@ packages: - liblapacke 3.11.0 5*_mkl license: BSD-3-Clause license_family: BSD + purls: [] size: 80225 timestamp: 1765819148014 - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-6_hf9ab0e9_mkl.conda @@ -18018,6 +19020,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27343190 timestamp: 1760724535115 @@ -18041,6 +19044,7 @@ packages: - cuda-version >=12.9,<12.10.0a0 - libnvptxcompiler-dev_win-64 12.9.86 h57928b3_2 license: LicenseRef-NVIDIA-End-User-License-Agreement + purls: [] run_exports: {} size: 27359 timestamp: 1753976279054 @@ -18080,6 +19084,7 @@ packages: - ucrt >=10.0.20348.0 - libzlib >=1.3.1,<2.0a0 license: zlib-acknowledgement + purls: [] size: 383155 timestamp: 1770691504832 - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.58-h7351971_0.conda @@ -18107,6 +19112,7 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: LGPL-2.1-or-later + purls: [] size: 2877820 timestamp: 1771301866036 - conda: https://conda.anaconda.org/conda-forge/win-64/librsvg-2.62.3-h15cfe45_0.conda @@ -18172,6 +19178,19 @@ packages: - libsqlite >=3.53.3,<4.0a0 size: 1315909 timestamp: 1782519131898 +- conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + sha256: 62e1c45ec71ab2e5deeeb0e47e7df6a609991e91d46348f16df50c68fee145c8 + md5: ca0d59f40a02a15e9b5d0ff8db0f85e3 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: blessing + run_exports: + weak: + - libsqlite >=3.53.4,<4.0a0 + size: 1313790 + timestamp: 1785016158097 - conda: https://conda.anaconda.org/conda-forge/win-64/libstdcxx-15.2.0-hae5796f_18.conda sha256: 7134b90a850f0e14f15bd0f0218fd728f19cd5c58420a90c2f561f58272b8519 md5: 7c09facd8f5aced6b4c146e1c4053e50 @@ -18182,6 +19201,7 @@ packages: - libstdcxx-ng ==15.2.0=*_18 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL + purls: [] size: 6462596 timestamp: 1771382223989 - conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.1-h8f73337_1.conda @@ -18287,6 +19307,7 @@ packages: - libxml2 2.15.2 license: MIT license_family: MIT + purls: [] size: 520731 timestamp: 1772704723763 - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.2-h692994f_0.conda @@ -18357,6 +19378,7 @@ packages: - vc14_runtime >=14.44.35208 license: MIT license_family: MIT + purls: [] size: 43866 timestamp: 1772704745691 - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda @@ -18387,6 +19409,7 @@ packages: - zlib 1.3.1 *_2 license: Zlib license_family: Other + purls: [] size: 55476 timestamp: 1727963768015 - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda @@ -18406,6 +19429,22 @@ packages: - libzlib >=1.3.2,<2.0a0 size: 58347 timestamp: 1774072851498 +- conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + sha256: 0629c2cc0404d3bb29d6baa7b4ba62da80797015e86de050db81ea5a07050527 + md5: 5d2ff29d465097458cc3ff6569151991 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 58529 + timestamp: 1785276664143 - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.0-h4fa8253_0.conda sha256: bb55a3736380759d338f87aac68df4fd7d845ae090b94400525f5d21a55eea31 md5: e5505e0b7d6ef5c19d5c0c1884a2f494 @@ -18418,6 +19457,7 @@ packages: - intel-openmp <0.0a0 license: Apache-2.0 WITH LLVM-exception license_family: APACHE + purls: [] size: 347404 timestamp: 1772025050288 - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.2-h4fa8253_0.conda @@ -18473,6 +19513,7 @@ packages: - msys2-conda-epoch <0.0a0 license: BSD-3-Clause license_family: BSD + purls: [] size: 7539 timestamp: 1747330852019 - conda: https://conda.anaconda.org/conda-forge/win-64/markupsafe-3.0.3-py314h2359020_1.conda @@ -18503,6 +19544,7 @@ packages: - vc14_runtime >=14.44.35208 license: LicenseRef-IntelSimplifiedSoftwareOct2022 license_family: Proprietary + purls: [] size: 100224829 timestamp: 1767634557029 - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2025.3.1-hac47afa_11.conda @@ -18545,6 +19587,8 @@ packages: - python_abi 3.14.* *_cp314 - numpy >=1.23,<3 license: MPL-2.0 AND Apache-2.0 + purls: + - pkg:pypi/ml-dtypes?source=hash-mapping size: 202093 timestamp: 1771362373159 - conda: https://conda.anaconda.org/conda-forge/win-64/msgpack-python-1.1.2-py314h909e829_1.conda @@ -18578,6 +19622,8 @@ packages: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping size: 7309134 timestamp: 1770098414535 - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.4.3-py314h02f10f6_0.conda @@ -18689,6 +19735,21 @@ packages: - openssl >=3.6.3,<4.0a0 size: 9414790 timestamp: 1781071745579 +- conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + sha256: 2ebff5a1b5793e82495bf33c91fba040e11ff23333c2385ac66d0c3aee2cc14c + md5: a978392692a910ba1c8920ccb1e784b3 + depends: + - ca-certificates + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: Apache-2.0 + license_family: Apache + run_exports: + weak: + - openssl >=3.6.3,<4.0a0 + size: 9427535 + timestamp: 1785915614585 - conda: https://conda.anaconda.org/conda-forge/win-64/pango-1.56.4-h03d888a_0.conda sha256: dcda7e9bedc1c87f51ceef7632a5901e26081a1f74a89799a3e50dbdc801c0bd md5: 452d6d3b409edead3bd90fc6317cd6d4 @@ -18708,6 +19769,7 @@ packages: - vc >=14.2,<15 - vc14_runtime >=14.29.30139 license: LGPL-2.1-or-later + purls: [] size: 454854 timestamp: 1751292618315 - conda: https://conda.anaconda.org/conda-forge/win-64/pango-1.56.4-h13911b6_1.conda @@ -18853,6 +19915,35 @@ packages: size: 18481352 timestamp: 1781256034828 python_site_packages_path: Lib/site-packages +- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda + build_number: 101 + sha256: 3a9ae901cd853d507d97aa8b72af4b9a572a3f92dcc5bad8a1318f77ff4e0e64 + md5: 67bbf51f88a2053513d7c78f485f7479 + depends: + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.3,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + run_exports: + weak: + - python_abi 3.14.* *_cp314 + noarch: + - python + size: 18338767 + timestamp: 1784911044838 + python_site_packages_path: Lib/site-packages - conda: https://conda.anaconda.org/conda-forge/win-64/pywin32-311-py314h8f8f202_1.conda sha256: 6918a8067f296f3c65d43e84558170c9e6c3f4dd735cfe041af41a7fdba7b171 md5: 2d7b7ba21e8a8ced0eca553d4d53f773 @@ -18994,6 +20085,7 @@ packages: - libvulkan-loader >=1.4.341.0,<2.0a0 - libusb >=1.0.29,<2.0a0 license: Zlib + purls: [] size: 1669623 timestamp: 1771668231217 - conda: https://conda.anaconda.org/conda-forge/win-64/shaderc-2025.5-h8fa7867_1.conda @@ -19007,6 +20099,7 @@ packages: - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: Apache + purls: [] size: 1558909 timestamp: 1770208850155 - conda: https://conda.anaconda.org/conda-forge/win-64/shaderc-2026.2-h8fa7867_0.conda @@ -19034,6 +20127,7 @@ packages: - spirv-headers >=1.4.341.0,<1.4.341.1.0a0 license: Apache-2.0 license_family: APACHE + purls: [] size: 13881533 timestamp: 1770089875437 - conda: https://conda.anaconda.org/conda-forge/win-64/spirv-tools-2026.2-h49e36cd_0.conda @@ -19167,6 +20261,17 @@ packages: run_exports: {} size: 21860770 timestamp: 1784166533243 +- conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + sha256: 15fdcce34c19c3dde9eab5550cd4eb9760cab80eb4e26305643b5cf0fd43d9be + md5: d791fa67f9e790de3bcb4961f3cfb145 + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + license: Apache-2.0 OR MIT + run_exports: {} + size: 15540330 + timestamp: 1785973546861 - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_34.conda sha256: 9dc40c2610a6e6727d635c62cced5ef30b7b30123f5ef67d6139e23d21744b3a md5: 1e610f2416b6acdd231c5f573d754a0f @@ -19192,6 +20297,18 @@ packages: run_exports: {} size: 20362 timestamp: 1781320968457 +- conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + sha256: 35444c55a92e2f7f7ba26bc70f81e56e52344f7d064c0fd4b40a46a58517b79c + md5: aa805b5522c2a98fa286e551a1f48546 + depends: + - vc14_runtime >=14.51.36247 + track_features: + - vc14 + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 21383 + timestamp: 1785359368566 - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_34.conda sha256: 02732f953292cce179de9b633e74928037fa3741eb5ef91c3f8bae4f761d32a5 md5: 37eb311485d2d8b2c419449582046a42 @@ -19219,6 +20336,19 @@ packages: run_exports: {} size: 737434 timestamp: 1781320964561 +- conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + sha256: 4e4cb599cdc41bf2109d1464c127b5bcbddf548ce3e322e612afb691338b48f8 + md5: ac5333bb3d429361f23adf704cc49a78 + depends: + - ucrt >=10.0.20348.0 + - vcomp14 14.51.36247 habf1de7_41 + constrains: + - vs2015_runtime 14.51.36247.* *_41 + license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime + license_family: Proprietary + run_exports: {} + size: 767955 + timestamp: 1785359364369 - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_34.conda sha256: 878d5d10318b119bd98ed3ed874bd467acbe21996e1d81597a1dbf8030ea0ce6 md5: 242d9f25d2ae60c76b38a5e42858e51d @@ -19246,6 +20376,20 @@ packages: - vcomp14 >=14.51.36231 size: 120684 timestamp: 1781320948530 +- conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda + sha256: 731e043390c9457299484d39e427221fc868a9249540a498a5a4f6456c7744d1 + md5: 350bb67a5c8e5f1c53347ac544ab6600 + depends: + - ucrt >=10.0.20348.0 + constrains: + - vs2015_runtime 14.51.36247.* *_41 + license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime + license_family: Proprietary + run_exports: + strong: + - vcomp14 >=14.51.36247 + size: 155910 + timestamp: 1785359349999 - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_34.conda sha256: 63ff4ec6e5833f768d402f5e95e03497ce211ded5b6f492e660e2bfc726ad24d md5: f276d1de4553e8fca1dfb6988551ebb4 @@ -19253,6 +20397,7 @@ packages: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD + purls: [] size: 19347 timestamp: 1767320221943 - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.51.36231-h84cd919_39.conda @@ -19283,6 +20428,24 @@ packages: - ucrt >=10.0.20348.0 size: 24190 timestamp: 1781320983107 +- conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_41.conda + sha256: 9d7d1b43cf4af5a8e8b1646175c9f899ffbcab189a33ac41127a96e7bcf41af0 + md5: 04190e0ebd886433300ce9343ee98942 + depends: + - vswhere + constrains: + - vs_win-64 2022.14 + track_features: + - vc14 + license: BSD-3-Clause + license_family: BSD + run_exports: + strong: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + size: 25462 + timestamp: 1785358620723 - conda: https://conda.anaconda.org/conda-forge/win-64/x264-1!164.3095-h8ffe710_2.tar.bz2 sha256: 97166b318f8c68ffe4d50b2f4bd36e415219eeaef233e7d41c54244dc6108249 md5: 19e39905184459760ccb8cf5c75f148b @@ -19363,7 +20526,7 @@ packages: - zstd >=1.5.7,<1.6.0a0 size: 388453 timestamp: 1764777142545 -- conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings +- conda_source: cuda-bindings[3db1bf41] @ ../cuda_bindings variants: c_stdlib: sysroot c_stdlib_version: '2.28' @@ -19382,9 +20545,9 @@ packages: - libnvfatbin - libcufile - libcufile >=1.18.1.6,<2.0a0 - - libgcc >=15 - - libgcc >=15 - - libstdcxx >=15 + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 - __glibc >=2.28,<3.0.a0 - python_abi 3.14.* *_cp314 license: Apache-2.0 @@ -19395,25 +20558,25 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-16.1.0-h04da0f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-16.1.0-hed00b63_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-16.1.0-hd5c6868_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-16.1.0-h4223dcb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-16.1.0-h2510bd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-16.1.0-hd673532_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-16.1.0-h2445e1f_101.conda - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda @@ -19424,51 +20587,50 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.73-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-dev-1.18.1.6-he38c790_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.73-h579c4fd_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder -- conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder +- conda_source: cuda-bindings[4664b262] @ ../cuda_bindings variants: c_compiler: vs2022 cuda_version: 13.3.* @@ -19495,25 +20657,25 @@ packages: path: ../cuda_pathfinder build_packages: - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_41.conda host_packages: - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-13.3.73-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_win-64-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-13.3.73-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-dev-13.3.29-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-static-13.3.29-hac47afa_0.conda @@ -19528,25 +20690,25 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.11.29-h7ca4a90_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder -- conda_source: cuda-bindings[91169b48] @ ../cuda_bindings + - conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder +- conda_source: cuda-bindings[4e633ee8] @ ../cuda_bindings variants: c_stdlib: sysroot c_stdlib_version: '2.28' cuda_version: 13.3.* python: 3.14.* - target_platform: linux-64 + target_platform: linux-aarch64 depends: - python - python >=3.10 @@ -19569,141 +20731,43 @@ packages: cuda-pathfinder: path: ../cuda_pathfinder build_packages: - - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.46.1-default_h4852527_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-15.2.0-he0086c7_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-15.2.0-h7be306e_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-15.2.0-hda75c37_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-15.2.0-hcb00b6d_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-15.2.0-h90f66d4_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.2.0-hd446a21_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - host_packages: - - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-13.3.29-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-13.3.33-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-13.3.33-hecca717_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-13.3.73-h69a702a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.73-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.73-h4bc722e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-hd0affe5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.18.1.6-h053a66a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.18.1.6-h676940d_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/rdma-core-63.0-h192683f_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.11.29-h2112641_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.73-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder -- conda_source: cuda-core[29d2d05a] @ . - variants: - c_stdlib: sysroot - c_stdlib_version: '2.28' - cuda_version: 13.3.* - python: 3.14.* - target_platform: linux-aarch64 - depends: - - python - - python >=3.10 - - cuda-version - - numpy - - cuda-bindings - - cuda-pathfinder - - backports.strenum - - libgcc >=15 - - libgcc >=15 - - libstdcxx >=15 - - __glibc >=2.28,<3.0.a0 - - python_abi 3.14.* *_cp314 - - cuda-nvrtc >=13.3.33,<14.0a0 - - cuda-cudart >=13.3.29,<14.0a0 - license: Apache-2.0 - build_packages: - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-15.2.0-h3530432_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-15.2.0-h0bf4bd8_27.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-15.2.0-h03e2352_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-15.2.0-h7e4acf5_27.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-15.2.0-he19c465_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-15.2.0-ha7b1723_119.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-13.3.1-py314he6363bd_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-13.3.33-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-dev-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-13.3.73-he9431aa_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-tools-13.3.73-h7b14b0b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dlpack-1.3-hfae3067_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcudla-13.3.29-hfae3067_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-dev-1.18.1.6-he38c790_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda @@ -19711,8 +20775,6 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-13.3.33-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda @@ -19734,7 +20796,7 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-13.3.73-h579c4fd_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda @@ -19744,10 +20806,115 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda -- conda_source: cuda-core[5159f177] @ . + - conda_source: cuda-pathfinder[640a9949] @ ../cuda_pathfinder +- conda_source: cuda-bindings[6c91bfdd] @ ../cuda_bindings + variants: + c_stdlib: sysroot + c_stdlib_version: '2.28' + cuda_version: 13.3.* + python: 3.14.* + target_platform: linux-64 + depends: + - python + - python >=3.10 + - cuda-version + - cuda-pathfinder + - libnvjitlink + - cuda-nvrtc + - cuda-nvrtc >=13.3.33,<14.0a0 + - cuda-nvvm + - libnvfatbin + - libcufile + - libcufile >=1.18.1.6,<2.0a0 + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 + - __glibc >=2.28,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + source_depends: + cuda-pathfinder: + path: ../cuda_pathfinder + build_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.46.1-default_h4852527_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-16.1.0-h5fcb69b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-16.1.0-h5fd2508_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-16.1.0-he33a5f8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-16.1.0-h5525346_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-16.1.0-hf2715c6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-16.1.0-h59071f9_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-16.1.0-h41cdd0d_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-13.3.73-h69a702a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.73-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.73-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.18.1.6-h053a66a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.18.1.6-h676940d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rdma-core-63.0-h192683f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.73-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder +- conda_source: cuda-bindings[8b6a309f] @ ../cuda_bindings variants: c_compiler: vs2022 - cuda_version: 12.* + cuda_version: 13.3.* cxx_compiler: vs2022 python: 3.14.* target_platform: win-64 @@ -19755,32 +20922,32 @@ packages: - python - python >=3.10 - cuda-version - - numpy - - cuda-bindings - cuda-pathfinder - - backports.strenum + - libnvjitlink + - cuda-nvrtc + - cuda-nvrtc >=13.3.33,<14.0a0 + - cuda-nvvm + - libnvfatbin - vc >=14.3,<15 - vc14_runtime >=14.44.35208 - ucrt >=10.0.20348.0 - python_abi 3.14.* *_cp314 - - cuda-nvrtc >=12.9.86,<13.0a0 - - cuda-cudart >=12.9.79,<13.0a0 license: Apache-2.0 + source_depends: + cuda-pathfinder: + path: ../cuda_pathfinder build_packages: - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda host_packages: - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-12.9.27-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-12.9.86-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_win-64-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_win-64-12.9.86-h36c15f3_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-12.9.86-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_win-64-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-13.3.73-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_win-64-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-13.3.73-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda @@ -19790,25 +20957,20 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-12.9.7-py314h2547b3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-crt-tools-12.9.86-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-dev-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-static-12.9.79-he0c23c2_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvcc-impl-12.9.86-h53cbb54_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvcc-tools-12.9.86-he0c23c2_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-12.9.86-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-dev-12.9.86-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-12.9.86-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-12.9.86-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-dev-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-static-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-13.3.33-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-dev-13.3.33-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-13.3.73-h719f0c7_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.73-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-13.3.73-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-profiler-api-13.3.27-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/dlpack-1.3-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libnvjitlink-12.9.86-hac47afa_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libnvptxcompiler-dev-12.9.86-h57928b3_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda @@ -19820,29 +20982,35 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda -- conda_source: cuda-core[5f946272] @ . + - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder +- conda_source: cuda-bindings[91169b48] @ ../cuda_bindings variants: c_stdlib: sysroot c_stdlib_version: '2.28' - cuda_version: 12.* + cuda_version: 13.3.* python: 3.14.* target_platform: linux-64 depends: - python - python >=3.10 - cuda-version - - numpy - - cuda-bindings - cuda-pathfinder - - backports.strenum + - libnvjitlink + - cuda-nvrtc + - cuda-nvrtc >=13.3.33,<14.0a0 + - cuda-nvvm + - libnvfatbin + - libcufile + - libcufile >=1.18.1.6,<2.0a0 - libgcc >=15 - libgcc >=15 - libstdcxx >=15 - __glibc >=2.28,<3.0.a0 - python_abi 3.14.* *_cp314 - - cuda-nvrtc >=12.9.86,<13.0a0 - - cuda-cudart >=12.9.79,<13.0a0 license: Apache-2.0 + source_depends: + cuda-pathfinder: + path: ../cuda_pathfinder build_packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda @@ -19866,23 +21034,20 @@ packages: host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-bindings-12.9.7-py314hadd79bd_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-crt-tools-12.9.86-ha770c72_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.9.79-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.9.79-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.9.79-h5888daf_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-impl-12.9.86-h85509e4_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-tools-12.9.86-he02047a_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.9.86-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-12.9.86-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.9.86-h4bc722e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.9.86-h4bc722e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.9.79-h7938cbb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-13.3.73-h69a702a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.73-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-13.3.73-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/dlpack-1.3-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-hd0affe5_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.14.1.1-hbc026e6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.18.1.6-h053a66a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-dev-1.18.1.6-h676940d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda @@ -19890,8 +21055,6 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-12.9.86-hecca717_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvptxcompiler-dev-12.9.86-ha770c72_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda @@ -19907,16 +21070,13 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.11.29-h2112641_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.9.27-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.9.86-ha770c72_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.9.79-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.9.79-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.9.79-h3f2d84a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_linux-64-12.9.86-he91c749_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.9.86-ha770c72_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_linux-64-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-13.3.73-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda @@ -19925,11 +21085,88 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda -- conda_source: cuda-core[70e83c84] @ . + - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder +- conda_source: cuda-core[18c68942] @ . + variants: + c_compiler: vs2022 + cuda_version: 12.* + cxx_compiler: vs2022 + python: 3.14.* + target_platform: win-64 + depends: + - python + - python >=3.10 + - cuda-version + - numpy + - cuda-bindings + - cuda-pathfinder + - backports.strenum + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + - cuda-nvrtc >=12.9.86,<13.0a0 + - cuda-cudart >=12.9.79,<13.0a0 + license: Apache-2.0 + build_packages: + - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_41.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-12.9.27-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_win-64-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_win-64-12.9.86-h36c15f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_win-64-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.6.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_win-64-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-12.9.7-py314h2547b3f_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-crt-tools-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-dev-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-cudart-static-12.9.79-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvcc-impl-12.9.86-h53cbb54_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvcc-tools-12.9.86-he0c23c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-12.9.86-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-dev-12.9.86-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-12.9.86-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-tools-12.9.86-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/dlpack-1.3-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libnvjitlink-12.9.86-hac47afa_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libnvptxcompiler-dev-12.9.86-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda +- conda_source: cuda-core[29d2d05a] @ . variants: c_stdlib: sysroot c_stdlib_version: '2.28' - cuda_version: 12.* + cuda_version: 13.3.* python: 3.14.* target_platform: linux-aarch64 depends: @@ -19945,8 +21182,8 @@ packages: - libstdcxx >=15 - __glibc >=2.28,<3.0.a0 - python_abi 3.14.* *_cp314 - - cuda-nvrtc >=12.9.86,<13.0a0 - - cuda-cudart >=12.9.79,<13.0a0 + - cuda-nvrtc >=13.3.33,<14.0a0 + - cuda-cudart >=13.3.29,<14.0a0 license: Apache-2.0 build_packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda @@ -19971,6 +21208,172 @@ packages: host_packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-13.3.1-py314he6363bd_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-dev-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dlpack-1.3-hfae3067_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcudla-13.3.29-hfae3067_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda +- conda_source: cuda-core[2b0a529b] @ . + variants: + c_compiler: vs2022 + cuda_version: 13.3.* + cxx_compiler: vs2022 + python: 3.14.* + target_platform: win-64 + depends: + - python + - python >=3.10 + - cuda-version + - numpy + - cuda-bindings + - cuda-pathfinder + - backports.strenum + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - cuda-nvrtc >=13.3.33,<14.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + build_packages: + - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_41.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_win-64-13.3.3.4.1-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_win-64-13.3.73-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_win-64-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_win-64-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_win-64-13.3.29-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.6.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-bindings-13.3.1-py314hb98de8c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-13.3.33-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvrtc-dev-13.3.33-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cuda-nvvm-impl-13.3.73-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cython-3.2.9-py314h344ed54_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/dlpack-1.3-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libnvfatbin-13.3.29-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libnvjitlink-13.3.33-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda +- conda_source: cuda-core[6e9d4edb] @ . + variants: + c_stdlib: sysroot + c_stdlib_version: '2.28' + cuda_version: 12.* + python: 3.14.* + target_platform: linux-aarch64 + depends: + - python + - python >=3.10 + - cuda-version + - numpy + - cuda-bindings + - cuda-pathfinder + - backports.strenum + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 + - __glibc >=2.28,<3.0.a0 + - python_abi 3.14.* *_cp314 + - cuda-nvrtc >=12.9.86,<13.0a0 + - cuda-cudart >=12.9.79,<13.0a0 + license: Apache-2.0 + build_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-16.1.0-h04da0f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-16.1.0-hed00b63_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-16.1.0-hd5c6868_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-16.1.0-h4223dcb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-16.1.0-h2510bd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-16.1.0-hd673532_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-16.1.0-h2445e1f_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-12.9.7-py314hd8c1704_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-crt-tools-12.9.86-h579c4fd_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-12.9.79-h3ae8b8a_0.conda @@ -19985,53 +21388,152 @@ packages: - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-12.9.79-h16bee8c_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dlpack-1.3-hfae3067_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hf9559e3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.14.1.1-had8bf56_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.14.1.1-had8bf56_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-12.9.86-h8f3c8d4_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvptxcompiler-dev-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-12.9.27-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-12.9.79-h3ae8b8a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_linux-aarch64-12.9.86-h4310d6a_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.6.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_linux-aarch64-12.9.86-h579c4fd_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda +- conda_source: cuda-core[7b4f4a3f] @ . + variants: + c_stdlib: sysroot + c_stdlib_version: '2.28' + cuda_version: 13.3.* + python: 3.14.* + target_platform: linux-aarch64 + depends: + - python + - python >=3.10 + - cuda-version + - numpy + - cuda-bindings + - cuda-pathfinder + - backports.strenum + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 + - __glibc >=2.28,<3.0.a0 + - cuda-cudart >=13.3.29,<14.0a0 + - cuda-nvrtc >=13.3.33,<14.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + build_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.46.1-default_h5f4c503_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.46.1-default_hf1166c9_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-16.1.0-h04da0f0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-16.1.0-hed00b63_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-16.1.0-hd5c6868_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-16.1.0-h4223dcb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-16.1.0-h2510bd8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-16.1.0-hd673532_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-16.1.0-h2445e1f_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-bindings-13.3.1-py314he6363bd_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-dev-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-cudart-static-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvrtc-dev-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-nvvm-impl-13.3.73-h7b14b0b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cuda-profiler-api-13.3.27-h16bee8c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cython-3.2.9-py314hc6b4731_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dlpack-1.3-hfae3067_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcap-2.78-hfcc8634_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcudla-13.3.29-hfae3067_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcufile-1.18.1.6-h42688b2_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnl-3.11.0-h86ecc28_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-12.9.86-h8f3c8d4_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvptxcompiler-dev-12.9.86-h579c4fd_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvfatbin-13.3.29-h8f3c8d4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnvjitlink-13.3.33-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsystemd0-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libudev1-257.13-hfcc8634_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rdma-core-63.0-h1f0f388_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.11.29-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda - conda: https://conda.anaconda.org/conda-forge/noarch/arm-variant-1.2.0-sbsa.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-12.9.27-h579c4fd_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-12.9.86-h579c4fd_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-12.9.79-h3ae8b8a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_linux-aarch64-12.9.86-h4310d6a_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-aarch64-12.9.86-h579c4fd_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.5.6-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_linux-aarch64-12.9.86-h579c4fd_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-aarch64-13.3.3.4.1-h579c4fd_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-aarch64-13.3.73-h579c4fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-aarch64-13.3.29-h8f3c8d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.6.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda - conda_source: cuda-core[83c371ca] @ . variants: c_stdlib: sysroot @@ -20130,6 +21632,211 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda +- conda_source: cuda-core[adf7f1da] @ . + variants: + c_stdlib: sysroot + c_stdlib_version: '2.28' + cuda_version: 13.3.* + python: 3.14.* + target_platform: linux-64 + depends: + - python + - python >=3.10 + - cuda-version + - numpy + - cuda-bindings + - cuda-pathfinder + - backports.strenum + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 + - __glibc >=2.28,<3.0.a0 + - cuda-cudart >=13.3.29,<14.0a0 + - cuda-nvrtc >=13.3.33,<14.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + build_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.46.1-default_h4852527_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-16.1.0-h5fcb69b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-16.1.0-h5fd2508_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-16.1.0-he33a5f8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-16.1.0-h5525346_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-16.1.0-hf2715c6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-16.1.0-h59071f9_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-16.1.0-h41cdd0d_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-bindings-13.3.1-py314h42812f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-13.3.29-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-13.3.73-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-13.3.27-h7938cbb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/dlpack-1.3-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.18.1.6-h053a66a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvfatbin-13.3.29-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-13.3.33-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rdma-core-63.0-h192683f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-13.3.3.4.1-ha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-13.3.73-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-13.3.29-h376f20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.6.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-13.3-hcbadf70_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda +- conda_source: cuda-core[e53261c5] @ . + variants: + c_stdlib: sysroot + c_stdlib_version: '2.28' + cuda_version: 12.* + python: 3.14.* + target_platform: linux-64 + depends: + - python + - python >=3.10 + - cuda-version + - numpy + - cuda-bindings + - cuda-pathfinder + - backports.strenum + - libgcc >=16 + - libgcc >=16 + - libstdcxx >=16 + - __glibc >=2.28,<3.0.a0 + - python_abi 3.14.* *_cp314 + - cuda-nvrtc >=12.9.86,<13.0a0 + - cuda-cudart >=12.9.79,<13.0a0 + license: Apache-2.0 + build_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.46.1-default_h4852527_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-16.1.0-h5fcb69b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-16.1.0-h5fd2508_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-16.1.0-he33a5f8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-16.1.0-h5525346_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-16.1.0-hf2715c6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-16.1.0-h59071f9_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-16.1.0-h41cdd0d_101.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-bindings-12.9.7-py314hadd79bd_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-crt-tools-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-dev-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-cudart-static-12.9.79-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-impl-12.9.86-h85509e4_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvcc-tools-12.9.86-he02047a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-12.9.86-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvrtc-dev-12.9.86-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-impl-12.9.86-h4bc722e_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-nvvm-tools-12.9.86-h4bc722e_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cuda-profiler-api-12.9.79-h7938cbb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cython-3.2.8-py314h1807b08_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/dlpack-1.3-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcap-2.78-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcufile-1.14.1.1-hbc026e6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnl-3.11.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvjitlink-12.9.86-hecca717_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnvptxcompiler-dev-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsystemd0-257.13-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libudev1-257.13-h084b8d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rdma-core-63.0-h192683f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cccl_linux-64-12.9.27-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-crt-dev_linux-64-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-dev_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart-static_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-cudart_linux-64-12.9.79-h3f2d84a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvcc-dev_linux-64-12.9.86-he91c749_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-nvvm-dev_linux-64-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-pathfinder-1.6.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cuda-version-12.9-h4f385c5_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libnvptxcompiler-dev_linux-64-12.9.86-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda - conda_source: cuda-core[e56c61a7] @ . variants: c_compiler: vs2022 @@ -20195,6 +21902,39 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda +- conda_source: cuda-pathfinder[15190cc4] @ ../cuda_pathfinder + variants: + target_platform: noarch + depends: + - python >=3.10 + - python * + license: Apache-2.0 + host_packages: + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_10.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.4-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h967ab96_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/uv-0.12.2-h7ca4a90_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-ha367084_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36247-habf1de7_41.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - conda_source: cuda-pathfinder[3890e449] @ ../cuda_pathfinder variants: target_platform: noarch @@ -20270,6 +22010,44 @@ packages: - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.2-pyhcf101f3_0.conda +- conda_source: cuda-pathfinder[9139f4b4] @ ../cuda_pathfinder + variants: + target_platform: noarch + depends: + - python >=3.10 + - python * + license: Apache-2.0 + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h54a6638_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.1.0-ha9f2e26_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.1.0-he0feb66_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-hf4e2dac_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.1.0-h934c35e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd70dff1_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/uv-0.12.2-h2112641_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda - conda_source: cuda-pathfinder[bcd0ad48] @ ../cuda_pathfinder variants: target_platform: noarch @@ -20303,6 +22081,46 @@ packages: - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda +- conda_source: cuda-pathfinder[fa19867f] @ ../cuda_pathfinder + variants: + target_platform: noarch + depends: + - python >=3.10 + - python * + license: Apache-2.0 + host_packages: + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.46.1-default_h1979696_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-16.1.0-h205dda4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-16.1.0-h8acb6b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.4-h022381a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-16.1.0-hef695bb_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_101_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5cf4473_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/uv-0.12.2-hbe9c82f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-83.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-scm-10.2.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/vcs_versioning-2.2.3-pyhcf101f3_0.conda +- pypi: ../cuda_python_test_helpers + name: cuda-python-test-helpers + requires_python: '>=3.10' - pypi: https://files.pythonhosted.org/packages/01/8a/f767031dcd0d24c2bbab4b696dbcf004da4f3284e5e4649fc47bc0e2bb78/nvidia_nvvm-13.3.33-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl name: nvidia-nvvm version: 13.3.33 diff --git a/cuda_core/pixi.toml b/cuda_core/pixi.toml index 928ea718ff2..b2c6a3389c3 100644 --- a/cuda_core/pixi.toml +++ b/cuda_core/pixi.toml @@ -16,9 +16,6 @@ cuda-version = ["12.*", "13.3.*"] cuda-core = { path = "." } ml_dtypes = "*" pytest = "*" - -[feature.test.pypi-dependencies] -cuda-python-test-helpers = { path = "../cuda_python_test_helpers", editable = true } pytest-benchmark = "*" pytest-randomly = "*" pytest-repeat = "*" @@ -28,6 +25,9 @@ docutils = "*" psutil = "*" pyglet = "*" +[feature.test.pypi-dependencies] +cuda-python-test-helpers = { path = "../cuda_python_test_helpers", editable = true } + [feature.examples.dependencies] cuda-core = { path = "." } cffi = "*" From 757731a10a7a166ffe4e346ca246415695712402 Mon Sep 17 00:00:00 2001 From: Andy Jost Date: Mon, 10 Aug 2026 08:56:38 -0700 Subject: [PATCH 49/50] ci: limit pytest duration reports to the slowest 20 tests (#2523) * ci: limit pytest duration reports to the slowest 20 tests --durations=0 prints every test phase and floods CI logs. Report only the slowest 20 instead. * ci: set pytest --durations=20 via package config defaults Move the duration limit into pytest addopts so CI and local runs share one default, instead of repeating --durations on every command. --- .github/workflows/test-wheel-linux.yml | 6 +++--- .github/workflows/test-wheel-windows.yml | 6 +++--- ci/tools/run-tests | 10 +++++----- cuda_bindings/pyproject.toml | 2 +- cuda_core/pytest.ini | 2 +- cuda_pathfinder/pyproject.toml | 2 +- pytest.ini | 2 +- 7 files changed, 15 insertions(+), 15 deletions(-) diff --git a/.github/workflows/test-wheel-linux.yml b/.github/workflows/test-wheel-linux.yml index f2e7e5e5d39..4235e01d321 100644 --- a/.github/workflows/test-wheel-linux.yml +++ b/.github/workflows/test-wheel-linux.yml @@ -425,7 +425,7 @@ jobs: if: ${{ inputs.test-mode == 'nightly-pytorch' }} run: | pushd cuda_core - pytest -rxXs -v --durations=0 tests/test_utils.py tests/example_tests/ + pytest -rxXs -v tests/test_utils.py tests/example_tests/ popd - name: Run numba-cuda tests @@ -485,7 +485,7 @@ jobs: --deselect 'tests/numba_cuda_tests/cudadrv/test_nvjitlink.py::TestLinkerDumpAssembly::test_nvjitlink_jit_with_linkable_code_lto_dump_assembly_warn' ) fi - pytest -rxXs -v --durations=0 \ + pytest -rxXs -v \ --ignore=tests/benchmarks \ --ignore=tests/doc_examples \ "${DESELECTS[@]}" \ @@ -522,7 +522,7 @@ jobs: --deselect 'tests/test_enum_coverage.py::test_wrapper_covers_all_binding_members[NvlinkVersion]' ) fi - pytest -rxXs -v --durations=0 --randomly-dont-reorganize \ + pytest -rxXs -v --randomly-dont-reorganize \ "${DESELECTS[@]}" \ tests/ popd diff --git a/.github/workflows/test-wheel-windows.yml b/.github/workflows/test-wheel-windows.yml index 000843b9070..91da06d9eac 100644 --- a/.github/workflows/test-wheel-windows.yml +++ b/.github/workflows/test-wheel-windows.yml @@ -409,7 +409,7 @@ jobs: shell: bash --noprofile --norc -xeuo pipefail {0} run: | pushd cuda_core - pytest -rxXs -v --durations=0 tests/test_utils.py tests/example_tests/ + pytest -rxXs -v tests/test_utils.py tests/example_tests/ popd - name: Run numba-cuda tests @@ -452,7 +452,7 @@ jobs: --deselect 'tests/numba_cuda_tests/cudapy/test_cuda_array_interface.py::TestCudaArrayInterface::test_fortran_contiguous' ) fi - pytest -rxXs -v --durations=0 \ + pytest -rxXs -v \ --ignore=tests/benchmarks \ --ignore=tests/doc_examples \ "${DESELECTS[@]}" \ @@ -494,7 +494,7 @@ jobs: --deselect 'tests/test_memory.py::test_non_managed_resources_report_not_managed[pinned]' ) fi - pytest -rxXs -v --durations=0 --randomly-dont-reorganize \ + pytest -rxXs -v --randomly-dont-reorganize \ "${DESELECTS[@]}" \ tests/ popd diff --git a/ci/tools/run-tests b/ci/tools/run-tests index c093ed9e4d2..f9cc5a9e870 100755 --- a/ci/tools/run-tests +++ b/ci/tools/run-tests @@ -36,7 +36,7 @@ if [[ "${test_module}" == "pathfinder" ]]; then "LD:${CUDA_PATHFINDER_TEST_LOAD_NVIDIA_DYNAMIC_LIB_STRICTNESS} " \ "FH:${CUDA_PATHFINDER_TEST_FIND_NVIDIA_HEADERS_STRICTNESS} " \ "BC:${CUDA_PATHFINDER_TEST_FIND_NVIDIA_BITCODE_LIB_STRICTNESS}" - pytest -ra -s -v --durations=0 tests/ |& tee /tmp/pathfinder_test_log.txt + pytest -ra -s -v tests/ |& tee /tmp/pathfinder_test_log.txt # Report the number of "INFO test_" lines (including zero) # to support quick validations based on GHA log archives. line_count=$(awk '/^INFO test_/ {count++} END {print count+0}' /tmp/pathfinder_test_log.txt) @@ -51,9 +51,9 @@ elif [[ "${test_module}" == "bindings" ]]; then pip install $(ls "${CUDA_BINDINGS_ARTIFACTS_DIR}"/*.whl)[all] --group test fi echo "Running bindings tests" - ${SANITIZER_CMD} pytest -rxXs -v --durations=0 --randomly-dont-reorganize tests/ + ${SANITIZER_CMD} pytest -rxXs -v --randomly-dont-reorganize tests/ if [[ "${SKIP_CYTHON_TEST}" == 0 ]]; then - ${SANITIZER_CMD} pytest -rxXs -v --durations=0 --randomly-dont-reorganize tests/cython + ${SANITIZER_CMD} pytest -rxXs -v --randomly-dont-reorganize tests/cython fi popd elif [[ "${test_module}" == "core" || "${test_module}" == nightly-* ]]; then @@ -105,11 +105,11 @@ elif [[ "${test_module}" == "core" || "${test_module}" == nightly-* ]]; then echo "Installed packages before core tests:" pip list echo "Running core tests" - ${SANITIZER_CMD} pytest -rxXs -v --durations=0 --randomly-dont-reorganize tests/ + ${SANITIZER_CMD} pytest -rxXs -v --randomly-dont-reorganize tests/ # Currently our CI always installs the latest bindings (from either major version). # This is not compatible with the test requirements. if [[ "${SKIP_CYTHON_TEST}" == 0 ]]; then - ${SANITIZER_CMD} pytest -rxXs -v --durations=0 --randomly-dont-reorganize tests/cython + ${SANITIZER_CMD} pytest -rxXs -v --randomly-dont-reorganize tests/cython fi popd elif [[ "${test_module}" == "nightly-cuda-core" ]]; then diff --git a/cuda_bindings/pyproject.toml b/cuda_bindings/pyproject.toml index 35739a4fedc..3896e4527ec 100644 --- a/cuda_bindings/pyproject.toml +++ b/cuda_bindings/pyproject.toml @@ -89,7 +89,7 @@ repair-wheel-command = "delvewheel repair --namespace-pkg cuda -w {dest_dir} {wh [tool.pytest.ini_options] required_plugins = "pytest-benchmark" -addopts = "--benchmark-disable --showlocals" +addopts = "--benchmark-disable --showlocals --durations=20" norecursedirs = ["tests/cython", "examples"] xfail_strict = true # Keep this authorship marker registry in sync across all pytest config roots. diff --git a/cuda_core/pytest.ini b/cuda_core/pytest.ini index dcb7cc84929..64fcf312a79 100644 --- a/cuda_core/pytest.ini +++ b/cuda_core/pytest.ini @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 [pytest] -addopts = --showlocals +addopts = --showlocals --durations=20 norecursedirs = cython markers = # Keep this authorship marker registry in sync across all pytest config roots. diff --git a/cuda_pathfinder/pyproject.toml b/cuda_pathfinder/pyproject.toml index 227b8fa4eb7..4fd7a5e3edf 100644 --- a/cuda_pathfinder/pyproject.toml +++ b/cuda_pathfinder/pyproject.toml @@ -103,7 +103,7 @@ tag_regex = "^cuda-pathfinder-(?Pv\\d+\\.\\d+\\.\\d+(?:[ab]\\d+)?)" git_describe_command = [ "git", "describe", "--dirty", "--tags", "--long", "--match", "cuda-pathfinder-v*[0-9]*" ] [tool.pytest.ini_options] -addopts = "--showlocals" +addopts = "--showlocals --durations=20" thread_unsafe_fixtures = ['mocker'] # Keep this authorship marker registry in sync across all pytest config roots. # Search for "agent_authored(model)" before editing. diff --git a/pytest.ini b/pytest.ini index 148b722aca2..505b4269490 100644 --- a/pytest.ini +++ b/pytest.ini @@ -2,7 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 [pytest] -addopts = --showlocals +addopts = --showlocals --durations=20 norecursedirs = cuda_bindings/examples cuda_core/examples From 5ac37a904c4d5734fe91d1917aae906162c53680 Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Mon, 10 Aug 2026 23:16:17 -0700 Subject: [PATCH 50/50] Fix SM resource alignment discovery test (#2389) * Fix SM resource alignment discovery test * Refine SM discovery alignment coverage * Document CUDA 13.4 SM discovery behavior --- cuda_core/docs/source/release/1.2.0-notes.rst | 12 +++++++ cuda_core/tests/test_green_context.py | 32 +++++++++++++++++-- 2 files changed, 41 insertions(+), 3 deletions(-) diff --git a/cuda_core/docs/source/release/1.2.0-notes.rst b/cuda_core/docs/source/release/1.2.0-notes.rst index 120d2c2a253..ef28e7931e4 100644 --- a/cuda_core/docs/source/release/1.2.0-notes.rst +++ b/cuda_core/docs/source/release/1.2.0-notes.rst @@ -73,6 +73,18 @@ Fixes and enhancements Windows, both ``ctypes.CFUNCTYPE`` and ``ctypes.WINFUNCTYPE`` are accepted. (`#2439 `__) +- Starting with CUDA 13.4, unconstrained SM-resource discovery through + :meth:`SMResource.split` with ``SMResourceOptions(count=None)`` may return + every available SM, even when that count is not divisible by the device's + :attr:`SMResource.coscheduled_alignment`. CUDA 13.1 through 13.3 returned an + aligned subset for the same request. An omitted or zero + ``coscheduled_sm_count`` still selects the driver's default internally, but + CUDA 13.4 no longer guarantees that the returned :attr:`SMResource.sm_count` + is a multiple of that default. A green context created from the discovered + group may therefore span the full GPU and leave an empty remainder. Set + ``coscheduled_sm_count`` explicitly when an aligned result is required. + (`#2389 `__) + Deprecation Notices ------------------- diff --git a/cuda_core/tests/test_green_context.py b/cuda_core/tests/test_green_context.py index 24ad6db482b..7b3d99cc7e4 100644 --- a/cuda_core/tests/test_green_context.py +++ b/cuda_core/tests/test_green_context.py @@ -405,11 +405,37 @@ def test_discovery_mode(self, sm_resource): assert len(groups) == 1 assert groups[0].sm_count >= sm_resource.min_partition_size - def test_discovery_respects_alignment(self, sm_resource): + @pytest.mark.agent_authored(model="gpt-5.6-sol") + def test_by_count_discovery_respects_alignment(self, sm_resource): + """CUDA 12 SplitByCount discovery returns an aligned SM count.""" + if binding_version()[0] != 12: + pytest.skip("test covers the CUDA 12 SplitByCount path") + groups, _ = sm_resource.split(SMResourceOptions(count=None)) - if sm_resource.coscheduled_alignment > 0: - assert groups[0].sm_count % sm_resource.coscheduled_alignment == 0 + assert groups[0].sm_count % sm_resource.coscheduled_alignment == 0 + + def test_discovery_respects_explicit_coscheduled_sm_count(self, sm_resource): + """Constrain discovery explicitly because unconstrained discovery may use all SMs.""" + if driver_version() < (13, 1, 0): + pytest.skip("explicit co-scheduled SM discovery requires CUDA 13.1+") + + alignment = sm_resource.coscheduled_alignment + try: + groups, _ = sm_resource.split( + SMResourceOptions( + count=None, + coscheduled_sm_count=alignment, + ) + ) + except RuntimeError as exc: + pytest.skip(str(exc)) + except CUDAError as exc: + if _is_invalid_resource_configuration(exc): + pytest.skip(str(exc)) + raise + + assert groups[0].sm_count % alignment == 0 def test_two_groups(self, sm_resource): """Two-group split succeeds for a supported explicit request."""