dask-cuda 25.6.0__py3-none-any.whl → 25.8.0__py3-none-any.whl

shared-actions/telemetry-impls/summarize/send_trace.py

@@ -0,0 +1,409 @@
+# Copyright (c) 2019-2025, NVIDIA CORPORATION.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Process a GitHub workflow log record and output OpenTelemetry span data."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+import re
+import sys
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from opentelemetry import trace
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.trace.id_generator import IdGenerator
+from opentelemetry.trace.status import StatusCode
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from typing import Any
+
+match os.getenv("OTEL_EXPORTER_OTLP_PROTOCOL"):
+    case "http/protobuf":
+        from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+            OTLPSpanExporter,
+        )
+    case "grpc":
+        from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+            OTLPSpanExporter,
+        )
+    case _:
+        from opentelemetry.sdk.trace.export import (
+            ConsoleSpanExporter as OTLPSpanExporter,
+        )
+
+
+logging.basicConfig(level=logging.DEBUG)
+
+SpanProcessor = BatchSpanProcessor
+
+
+def parse_attributes(attrs: os.PathLike | str | None) -> dict[str, str]:
+    """Attempt to parse attributes in a given list `attrs`."""
+    attrs_list: list[str]
+    if not attrs:
+        return {}
+    try:
+        with Path(attrs).open() as attribute_file:
+            attrs_list = attribute_file.readlines()
+    except FileNotFoundError:
+        attrs_list = str(attrs).split(",")
+    attributes = {}
+    for attr in attrs_list:
+        try:
+            key, value = attr.split("=", 1)
+        except ValueError:
+            logging.warning("Invalid attribute: %s", attr)
+            continue
+        attributes[key] = value.strip().strip('"')
+        logging.debug("Attribute parsed: Key: %s, Value: %s", key, value)
+    return attributes
+
+
+def date_str_to_epoch(date_str: str, value_if_not_set: int | None = 0) -> int:
+    """Github logs come in RFC 3339; this converts to nanoseconds since epoch."""
+    if date_str:
+        # replace bit is to attach the UTC timezone to our datetime object, so
+        # that it doesn't "help" us by adjusting our string value, which is
+        # already in UTC
+        timestamp_ns = int(
+            datetime.strptime(date_str, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc).timestamp() * 1e9
+        )
+    else:
+        timestamp_ns = value_if_not_set or 0
+    return timestamp_ns
+
+
+def map_conclusion_to_status_code(conclusion: str) -> StatusCode:
+    """Map string conclusion from logs to OTel enum."""
+    if conclusion == "success":
+        return StatusCode.OK
+    if conclusion == "failure":
+        return StatusCode.ERROR
+    return StatusCode.UNSET
+
+
+class RapidsSpanIdGenerator(IdGenerator):
+    """ID Generator that generates span IDs. Trace IDs come from elsewhere."""
+
+    def __init__(self, trace_id: int, job_name: str) -> None:
+        """Initialize generator with trace ID and initial job_name."""
+        self.trace_id = trace_id
+        self.job_name = job_name
+        self.step_name = None
+
+    def update_job_name(self, job_name: str) -> None:
+        """Update the job name, which feeds into computing the span name."""
+        self.job_name = job_name
+        logging.debug("Job name updated: %s", self.job_name)
+
+    def update_step_name(self, step_name: str) -> None:
+        """Update the step name, which feeds into computing the span name."""
+        self.step_name = step_name
+        logging.debug("Step name updated: %s", self.step_name)
+
+    def generate_span_id(self) -> int:
+        """Get a new span ID.
+
+        This is called by the OpenTelemetry SDK as-is, without arguments.
+        To change the generated value here, use the update methods.
+        """
+        span_id = hashlib.sha256()
+        span_id.update(str(self.trace_id).encode())
+        span_id.update(bytes(self.job_name.encode()))
+        if self.step_name:
+            span_id.update(bytes(self.step_name.encode()))
+        return int(span_id.hexdigest()[:16], 16)
+
+    def generate_trace_id(self) -> int:
+        """Return the trace ID that is stored at initialization."""
+        return self.trace_id
+
+
+@dataclass
+class Compiler:
+    hits: int = 0
+    misses: int = 0
+    errors: int = 0
+
+    @property
+    def requests(self) -> int:
+        """Calculate the total requests."""
+        return self.hits + self.misses + self.errors
+
+    @property
+    def hit_rate(self) -> float:
+        """Calculate the cache hit rate."""
+        return self.hits / self.requests if self.requests > 0 else 0
+
+    @property
+    def miss_rate(self) -> float:
+        """Calculate the cache miss rate."""
+        return self.misses / self.requests if self.requests > 0 else 0
+
+    @property
+    def error_rate(self) -> float:
+        """Calculate the cache error rate."""
+        return self.errors / self.requests if self.requests > 0 else 0
+
+
+class SccacheStats:
+    requests: int = 0
+    compilers: dict[str, Compiler]
+
+    def __init__(self, requests: int, compilers: dict[str, Compiler]) -> None:
+        self.requests = requests
+        self.compilers = compilers
+
+    @property
+    def hits(self) -> int:
+        """Calculate the total cache hits."""
+        return sum(v.hits for v in self.compilers.values())
+
+    @property
+    def misses(self) -> int:
+        """Calculate the total cache misses."""
+        return sum(v.misses for v in self.compilers.values())
+
+    @property
+    def errors(self) -> int:
+        """Calculate the total cache errors."""
+        return sum(v.errors for v in self.compilers.values())
+
+    @property
+    def hit_rate(self) -> float:
+        """Calculate the total cache hit rate."""
+        return self.hits / self.requests if self.requests > 0 else 0
+
+    @property
+    def miss_rate(self) -> float:
+        """Calculate the total cache miss rate."""
+        return self.misses / self.requests if self.requests > 0 else 0
+
+    @property
+    def error_rate(self) -> float:
+        """Calculate the total cache error rate."""
+        return self.errors / self.requests if self.requests > 0 else 0
+
+
+def get_sccache_stats(artifact_folder: Path) -> dict[str, str]:
+    """Get sccache stats from the artifact folder."""
+    stats_files = list(artifact_folder.glob("sccache-stats*.txt"))
+    logging.debug("SCCache stats files: %s", stats_files)
+    parsed_stats = {}
+    lang_line_match = re.compile(r"Cache (?P<result>\w+) \((?P<lang>\w+)[^)]*\)\s*(?P<count>\d+)")
+    for file in stats_files:
+        with file.open() as f:
+            stats = SccacheStats(requests=0, compilers={"c": Compiler(), "cpp": Compiler(), "cuda": Compiler()})
+            print("SCCache stats file: %s", file)
+            for line in f:
+                print("Line: %s", line)
+                if match := re.match(r"^Compile\srequests\s+(\d+).*", line, re.IGNORECASE):
+                    stats.requests = int(match.group(1))
+                elif match := lang_line_match.match(line):
+                    compiler = stats.compilers[match.group("lang")]
+                    setattr(compiler, match.group("result"), int(match.group("count")))
+        stats_file_name = re.findall(r"sccache-stats[-]?(?P<name>\w+).txt", file.name)
+        if stats_file_name:
+            stats_file_name = stats_file_name[0]
+        else:
+            stats_file_name = "main_process"
+        parsed_stats[stats_file_name] = stats
+    return parsed_stats
+
+
+def process_job_blob(  # noqa: PLR0913
+    trace_id: int,
+    job: Mapping[str, Any],
+    env_vars: Mapping[str, str],
+    first_timestamp: int,
+    last_timestamp: int,
+) -> int:
+    """Transform job JSON into an OTel span."""
+    # This is the top-level workflow, which we account for with the root
+    # trace above
+    if job["name"] == env_vars.get("OTEL_SERVICE_NAME"):
+        logging.debug("Job name is the same as the service name: %s", job["name"])
+        return last_timestamp
+    # this cuts off matrix info from the job name, such that grafana can group
+    # these by name
+    if "/" in job["name"]:
+        job_name, matrix_part = job["name"].split("/", 1)
+        job_name = job_name.strip()
+        matrix_part = matrix_part.strip()
+    else:
+        job_name, matrix_part = job["name"], None
+
+    job_id = job["id"]
+    logging.info("Processing job: %s", job_name)
+    job_create = date_str_to_epoch(job["created_at"], first_timestamp)
+    job_start = date_str_to_epoch(job["started_at"], first_timestamp)
+    # this may get later in time as we progress through the steps. It is
+    # common to have the job completion time be earlier than the end of
+    # the final cleanup steps
+    job_last_timestamp = date_str_to_epoch(job["completed_at"], job_start)
+
+    if job_start == 0:
+        logging.info("Job is empty (no start time) - bypassing")
+        return last_timestamp
+
+    artifact_folder = Path.cwd() / f"telemetry-artifacts/telemetry-tools-artifacts-{job_id}"
+    attributes = {}
+    if (artifact_folder / "attrs").exists():
+        logging.debug("Found attribute file for job: %s", job_id)
+        attributes = parse_attributes(artifact_folder / "attrs")
+    else:
+        logging.debug("No attribute metadata found for job: %s", job_id)
+
+    attributes["service.name"] = job_name
+
+    sccache_stats = get_sccache_stats(artifact_folder)
+    logging.debug("SCCache stats: %s", sccache_stats)
+
+    job_provider = TracerProvider(
+        resource=Resource(attributes),
+        id_generator=RapidsSpanIdGenerator(trace_id=trace_id, job_name=job["name"]),
+    )
+    job_provider.add_span_processor(span_processor=SpanProcessor(OTLPSpanExporter()))
+    job_tracer = trace.get_tracer("GitHub Actions parser", "0.0.1", tracer_provider=job_provider)
+
+    with job_tracer.start_as_current_span(
+        name=matrix_part or job["name"],
+        start_time=job_create,
+        end_on_exit=False,
+    ) as job_span:
+        logging.debug("Job span created: %s", job_span)
+        job_span.set_status(map_conclusion_to_status_code(job["conclusion"]))
+
+        job_provider.id_generator.update_step_name("Start delay time")
+        delay_span = job_tracer.start_span(name="Start delay time", start_time=job_create)
+        delay_span.end(job_start)
+        logging.debug("Delay span created: %s", delay_span)
+
+        for step in job["steps"]:
+            step_start = date_str_to_epoch(step["started_at"], job_last_timestamp)
+            step_end = date_str_to_epoch(step["completed_at"], step_start)
+            job_last_timestamp = max(step_end, job_last_timestamp)
+            job_provider.id_generator.update_step_name(step["name"])
+            # Reset attributes for each step
+            span_attributes = {}
+
+            if (step_end - step_start) / 1e9 > 1:
+                logging.debug("processing step: %s", step["name"])
+                job_provider.id_generator.update_step_name(step["name"])
+                # Only add sccache attributes if this is a build step
+                if re.match(r"(?:[\w+]+\sbuild$)|(?:Build\sand\srepair.*)", step["name"], re.IGNORECASE):
+                    logging.debug("Adding sccache attributes for step: %s", step["name"])
+                    for file_name, stats in sccache_stats.items():
+                        span_attributes[f"sccache.{file_name}.hit_rate"] = stats.hit_rate
+                        span_attributes[f"sccache.{file_name}.miss_rate"] = stats.miss_rate
+                        span_attributes[f"sccache.{file_name}.error_rate"] = stats.error_rate
+                        span_attributes[f"sccache.{file_name}.requests"] = stats.requests
+                        for lang, lang_stats in stats.compilers.items():
+                            span_attributes[f"sccache.{file_name}.{lang}.hit_rate"] = lang_stats.hit_rate
+                            span_attributes[f"sccache.{file_name}.{lang}.miss_rate"] = lang_stats.miss_rate
+                            span_attributes[f"sccache.{file_name}.{lang}.error_rate"] = lang_stats.error_rate
+                            span_attributes[f"sccache.{file_name}.{lang}.requests"] = lang_stats.requests
+
+                # TODO: Ninja log files?
+                # TODO: file sizes of packages or their contents
+
+                step_span = job_tracer.start_span(
+                    name=step["name"],
+                    start_time=step_start,
+                    attributes=span_attributes,
+                )
+                logging.debug("Step span created: %s", step_span)
+                if span_attributes:
+                    logging.debug("    Step span attributes: %s", span_attributes)
+                # TODO: use step_span.record_exception(exc) to capture errors. exc is an exception object,
+                # so if we are reading from a log file, we need to read the log file into an exception object.
+                step_span.set_status(map_conclusion_to_status_code(step["conclusion"]))
+                step_span.end(step_end)
+                logging.debug("Step span ended: %s", step_span)
+            else:
+                logging.debug("Skipping step: %s, because its duration is < 1s", step["name"])
+        job_span.end(job_last_timestamp)
+        logging.debug("Job span ended: %s", job_span)
+    return last_timestamp
+
+
+def main() -> None:
+    """Run core functionality."""
+    with Path("all_jobs.json").open() as f:
+        jobs = json.loads(f.read())
+
+    first_timestamp = date_str_to_epoch(jobs[0]["created_at"])
+    # track the latest timestamp observed and use it for any unavailable times.
+    last_timestamp = date_str_to_epoch(jobs[0]["completed_at"], 0)
+
+    attribute_folders = list(Path.cwd().glob("telemetry-artifacts/telemetry-tools-artifacts-*"))
+    logging.debug("Attribute folders: %s", attribute_folders)
+    if attribute_folders:
+        attribute_file = attribute_folders[0] / "attrs"
+        attributes = parse_attributes(attribute_file.as_posix())
+        env_vars = parse_attributes(attribute_folders[0] / "telemetry-env-vars")
+        logging.debug("Env vars parsed from first attribute folder: %s", env_vars)
+    else:
+        attributes = {}
+        try:
+            env_vars = parse_attributes(Path.cwd() / "telemetry-artifacts/telemetry-env-vars")
+        except FileNotFoundError:
+            env_vars = os.environ
+    global_attrs = {k: v for k, v in attributes.items() if k.startswith("git.")}
+    if not (service_name := os.getenv("OTEL_SERVICE_NAME", env_vars.get("OTEL_SERVICE_NAME"))):
+        logging.error("OTEL_SERVICE_NAME not found in environment or attribute files")
+        sys.exit(1)
+    if not (trace_id := os.getenv("TRACEPARENT", env_vars.get("TRACEPARENT"))):
+        logging.error("TRACEPARENT not found in environment or attribute files")
+        sys.exit(1)
+    global_attrs["service.name"] = service_name
+    trace_id = int(trace_id.split("-")[1], 16)
+
+    logging.debug("Service name: %s", global_attrs["service.name"])
+    logging.debug("Trace ID: %s", trace_id)
+
+    provider = TracerProvider(
+        resource=Resource(global_attrs),
+        id_generator=RapidsSpanIdGenerator(trace_id=trace_id, job_name=global_attrs["service.name"]),
+    )
+    provider.add_span_processor(span_processor=SpanProcessor(OTLPSpanExporter()))
+    tracer = trace.get_tracer("GitHub Actions parser", "0.0.1", tracer_provider=provider)
+
+    with tracer.start_as_current_span(
+        name="Top-level workflow root", start_time=first_timestamp, end_on_exit=False
+    ) as root_span:
+        logging.debug("Root span created: %s", root_span)
+        for job in jobs:
+            last_timestamp = process_job_blob(
+                trace_id=trace_id,
+                job=job,
+                env_vars=env_vars,
+                first_timestamp=first_timestamp,
+                last_timestamp=last_timestamp,
+            )
+        root_span.end(last_timestamp)
+        logging.debug("Root span ended: %s", root_span)
+
+
+if __name__ == "__main__":
+    main()

dask_cuda-25.6.0.dist-info/RECORD

@@ -1,57 +0,0 @@
-dask_cuda/GIT_COMMIT,sha256=TiWUPXNqs5gL3lxRLAbL9S16XUILnjLBQ-tX9pxEkwE,41
-dask_cuda/VERSION,sha256=mkkPLCPxib-wy79AMMpM4Bq103DbRbHiXhZFFnGa_sk,8
-dask_cuda/__init__.py,sha256=Wbc7R0voN4vsQkb7SKuVXH0YXuXtfnAxrupxfM4lT10,1933
-dask_cuda/_compat.py,sha256=AG2lKGAtZitDPBjHeFDKLTN_B5HKodrhZ2kHlk1Z-D0,498
-dask_cuda/_version.py,sha256=cHDO9AzNtxkCVhwYu7hL3H7RPAkQnxpKBjElOst3rkI,964
-dask_cuda/cli.py,sha256=cScVyNiA_l9uXeDgkIcmbcR4l4cH1_1shqSqsVmuHPE,17053
-dask_cuda/cuda_worker.py,sha256=rZ1ITG_ZCbuaMA9e8uSqCjU8Km4AMphGGrxpBPQG8xU,9477
-dask_cuda/device_host_file.py,sha256=yS31LGtt9VFAG78uBBlTDr7HGIng2XymV1OxXIuEMtM,10272
-dask_cuda/disk_io.py,sha256=urSLKiPvJvYmKCzDPOUDCYuLI3r1RUiyVh3UZGRoF_Y,6626
-dask_cuda/get_device_memory_objects.py,sha256=peqXY8nAOtZpo9Pk1innP0rKySB8X4647YYqrwLYPHo,4569
-dask_cuda/initialize.py,sha256=Gjcxs_c8DTafgsHe5-2mw4lJdOmbFJJAZVOnxA8lTjM,6462
-dask_cuda/is_device_object.py,sha256=x9klFdeQzLcug7wZMxN3GK2AS121tlDe-LQ2uznm5yo,1179
-dask_cuda/is_spillable_object.py,sha256=8gj6QgtKcmzrpQwy8rE-pS1R8tjaJOeD-Fzr6LumjJg,1596
-dask_cuda/local_cuda_cluster.py,sha256=wqwKVRV6jT13sf9e-XsvbVBlTrnhmcbmHQBFPTFcayw,20335
-dask_cuda/plugins.py,sha256=A2aT8HA6q_JhIEx6-XKcpbWEbl7aTg1GNoZQH8_vh00,7197
-dask_cuda/proxify_device_objects.py,sha256=jWljqWddOT8NksyNKOh_9nFoV70_3P6s8P91oXdCfEk,8225
-dask_cuda/proxify_host_file.py,sha256=Wf5CFCC1JN5zmfvND3ls0M5FL01Y8VhHrk0xV3UQ9kk,30850
-dask_cuda/proxy_object.py,sha256=mrCCGwS-mltcY8oddJEXnPL6rV2dBpGgsFypBVbxRsA,30150
-dask_cuda/utils.py,sha256=wJ-oTj6mJHojz7JEMTh_QFnvz5igj4ULCbpI0r_XqMY,26273
-dask_cuda/utils_test.py,sha256=WNMR0gic2tuP3pgygcR9g52NfyX8iGMOan6juXhpkCE,1694
-dask_cuda/worker_spec.py,sha256=7-Uq_e5q2SkTlsmctMcYLCa9_3RiiVHZLIN7ctfaFmE,4376
-dask_cuda/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dask_cuda/benchmarks/common.py,sha256=YFhxBYkoxIV-2mddSbLwTbyg67U4zXDd2_fFq9oP3_A,6922
-dask_cuda/benchmarks/local_cudf_groupby.py,sha256=zrDiF-yBAUxVt9mWOTH5hUm-pb-XnVX-G9gvCEX7_GI,8512
-dask_cuda/benchmarks/local_cudf_merge.py,sha256=Q7lnZ87-O7j28hkS-i_5hMApTX8VsuI4ftZf2XAnp1E,12195
-dask_cuda/benchmarks/local_cudf_shuffle.py,sha256=Ied7r_fdGuOJyikBVVkMaIX3niJIlF39C1Xk6IVwgo4,8240
-dask_cuda/benchmarks/local_cupy.py,sha256=RCxQJd88bn3vyMAJDPK3orUpxzvDZY957wOSYkfriq0,10323
-dask_cuda/benchmarks/local_cupy_map_overlap.py,sha256=YAllGFuG6MePfPL8gdZ-Ld7a44-G0eEaHZJWB4vFPdY,6017
-dask_cuda/benchmarks/read_parquet.py,sha256=spKu6RLWYngPZq9hnaoU0mz7INIaJnErfqjBG2wH8Zc,7614
-dask_cuda/benchmarks/utils.py,sha256=_x0XXL_F3W-fExpuQfTBwuK3WnrVuXQQepbnvjUqS9o,30075
-dask_cuda/explicit_comms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dask_cuda/explicit_comms/comms.py,sha256=uq-XPOH38dFcYS_13Vomj2ER6zxQz7DPeSM000mOVmY,11541
-dask_cuda/explicit_comms/dataframe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dask_cuda/explicit_comms/dataframe/shuffle.py,sha256=yG9_7BuXSswiZjFfs6kVdHBA2-mlSBKN1i6phgNTJMY,23815
-dask_cuda/tests/test_cudf_builtin_spilling.py,sha256=qVN9J0Hdv66A9COFArLIdRriyyxEKpS3lEZGHbVHaq8,4903
-dask_cuda/tests/test_dask_cuda_worker.py,sha256=yG_RcOTF6vt-LBBVrjEQ_2vRZvVfFgFDMedPMSzkFws,20657
-dask_cuda/tests/test_device_host_file.py,sha256=79ssUISo1YhsW_7HdwqPfsH2LRzS2bi5BjPym1Sdgqw,5882
-dask_cuda/tests/test_dgx.py,sha256=BPCF4ZvhrVKkT43OOFHdijuo-M34vW3V18C8rRH1HXg,7489
-dask_cuda/tests/test_explicit_comms.py,sha256=hrNrTKP-pBSohyUqn1hnXKkUttGwRLeYY2bniEXM1FM,19944
-dask_cuda/tests/test_from_array.py,sha256=okT1B6UqHmLxoy0uER0Ylm3UyOmi5BAXwJpTuTAw44I,601
-dask_cuda/tests/test_gds.py,sha256=j1Huud6UGm1fbkyRLQEz_ysrVw__5AimwSn_M-2GEvs,1513
-dask_cuda/tests/test_initialize.py,sha256=4Ovv_ClokKibPX6wfuaoQgN4eKCohagRFoE3s3D7Huk,8119
-dask_cuda/tests/test_local_cuda_cluster.py,sha256=AiVUx3PkuIeobw1QXdr3mvom_l8DFVvRIvMQE91zAag,19811
-dask_cuda/tests/test_proxify_host_file.py,sha256=pFORynzqGpe9mz_rPwTVW6O4VoY2E0EmjsT7Ux_c920,19333
-dask_cuda/tests/test_proxy.py,sha256=U9uE-QesTwquNKzTReEKiYgoRgS_pfGW-A-gJNppHyg,23817
-dask_cuda/tests/test_spill.py,sha256=A4-pJWCfShUaEGKbUdeIpcVL8zCyyPfAjdlJ0As3LDQ,15462
-dask_cuda/tests/test_utils.py,sha256=PQI_oTONWnKSKlkQfEeK-vlmYa0-cPpDjDEbm74cNCE,9104
-dask_cuda/tests/test_version.py,sha256=vK2HjlRLX0nxwvRsYxBqhoZryBNZklzA-vdnyuWDxVg,365
-dask_cuda/tests/test_worker_spec.py,sha256=Bvu85vkqm6ZDAYPXKMJlI2pm9Uc5tiYKNtO4goXSw-I,2399
-dask_cuda-25.6.0.dist-info/licenses/LICENSE,sha256=MjI3I-EgxfEvZlgjk82rgiFsZqSDXHFETd2QJ89UwDA,11348
-examples/ucx/client_initialize.py,sha256=YN3AXHF8btcMd6NicKKhKR9SXouAsK1foJhFspbOn70,1262
-examples/ucx/local_cuda_cluster.py,sha256=7xVY3EhwhkY2L4VZin_BiMCbrjhirDNChoC86KiETNc,1983
-dask_cuda-25.6.0.dist-info/METADATA,sha256=Eolq3LbkRkU0ukh5enuHzLIK-YYo-Q_PX2bobo-rT1E,2345
-dask_cuda-25.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dask_cuda-25.6.0.dist-info/entry_points.txt,sha256=UcRaKVEpywtxc6pF1VnfMB0UK4sJg7a8_NdZF67laPM,136
-dask_cuda-25.6.0.dist-info/top_level.txt,sha256=S_m57qClWFTZ9rBMNTPikpBiy9vTn6_4pjGuInt0XE8,28
-dask_cuda-25.6.0.dist-info/RECORD,,

dask_cuda-25.6.0.dist-info/top_level.txt

@@ -1,4 +0,0 @@
-ci
-conda
-dask_cuda
-examples