torchft-nightly 2026.1.3__cp310-cp310-manylinux_2_24_x86_64.whl

torchft/quantization_test.py

@@ -0,0 +1,131 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from unittest import skipUnless, TestCase
+
+import torch
+from parameterized import parameterized
+from torch.distributed import ReduceOp
+
+from torchft import _test_utils
+
+torch.set_printoptions(precision=4, sci_mode=False)
+
+DEVICE = "cuda"
+
+try:
+    # pyre-fixme[21]: Could not find a module corresponding to import `triton`
+    import triton
+except ImportError:
+    pass
+else:
+    from torchft.quantization import (
+        fused_dequantize_from_fp8,
+        fused_quantize_into_fp8,
+        fused_reduce_fp8,
+    )
+
+    @skipUnless(
+        torch.cuda.is_available(),
+        "CUDA is required for this test",
+    )
+    class QuantizationTest(TestCase):
+        def run_test(
+            self,
+            world_size: int,
+            tensors_num: int,
+            tensor_size: int,
+            multiplier: float,
+            tolerance: float,
+            reduce_op: ReduceOp,
+            type: torch.dtype,
+        ) -> None:
+            inp = (
+                torch.rand(
+                    tensors_num * tensor_size,
+                    dtype=type,
+                    device="cuda",
+                )
+                * multiplier
+            )
+
+            for split in _test_utils.gen_splits(inp, tensor_size):
+                inputs = inp.clone()
+                outputs = torch.empty_like(inputs)
+
+                reshaped_inputs = []
+                reshaped_outputs = []
+                for s, i, o in zip(
+                    split,
+                    torch.split(inputs, tensor_size),
+                    torch.split(outputs, tensor_size),
+                ):
+                    reshaped_inputs.append(i.view(*s))
+                    reshaped_outputs.append(o.view(*s))
+
+                quant = fused_quantize_into_fp8(reshaped_inputs, world_size)
+                quant_slices = torch.split(quant, quant.numel() // world_size)
+
+                quant_final = torch.empty_like(quant)
+                quant_final_slices = torch.split(
+                    quant_final, quant_final.numel() // world_size
+                )
+
+                for rank in range(world_size):
+                    r = (rank) % world_size
+                    quant_copy = torch.empty_like(quant)
+                    quant_copy_slices = torch.split(
+                        quant_copy, quant_copy.numel() // world_size
+                    )
+                    for other in range(world_size):
+                        quant_copy_slices[other].copy_(quant_slices[r])
+
+                    fused_reduce_fp8(
+                        reshaped_inputs, quant_copy, world_size, r, reduce_op
+                    )
+
+                    quant_final_slices[r].copy_(quant_copy_slices[r])
+
+                fused_dequantize_from_fp8(reshaped_outputs, quant_final, world_size)
+
+                self.assertFalse(_test_utils.any_nan(reshaped_outputs))
+
+                if reduce_op == ReduceOp.SUM:
+                    inputs.mul_(world_size)
+
+                diff = torch.abs(
+                    (inputs - outputs).div(inputs.to(torch.float32) + 0.0000001)
+                )
+                mean_diff = diff.mean().item()
+                self.assertLessEqual(
+                    mean_diff, tolerance, f"Results not within tolerance {tolerance}"
+                )
+
+        END_TO_END_CONFIGS: list[tuple[int, float, ReduceOp, torch.dtype]] = [
+            (ts, m, o, t)
+            for ts in [128, 512, 4096]
+            for m in [1.0, 100.0, 1000.0]
+            for o in [ReduceOp.AVG, ReduceOp.SUM]
+            for t in [torch.float32, torch.float16, torch.bfloat16]
+        ]
+
+        @parameterized.expand(END_TO_END_CONFIGS)
+        def test_end_to_end(
+            self,
+            tensor_size: int,
+            multiplier: float,
+            reduce_op: ReduceOp,
+            type: torch.dtype,
+        ) -> None:
+            self.run_test(
+                world_size=2,
+                tensors_num=3,
+                tensor_size=tensor_size,
+                multiplier=multiplier,
+                tolerance=0.05,
+                reduce_op=reduce_op,
+                type=type,
+            )

torchft/torchx.py

@@ -0,0 +1,89 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+This is a file for TorchX components used for testing torchft.
+"""
+
+import os
+from typing import Dict, Optional
+
+import torchx.specs as specs
+
+
+def hsdp(
+    *script_args: str,
+    replicas: int = 2,
+    workers_per_replica: int = 1,
+    max_restarts: int = 10,
+    script: str = "train_ddp.py",
+    env: Optional[Dict[str, str]] = None,
+    image: str = "",
+    h: Optional[str] = None,
+    cpu: int = 2,
+    gpu: int = 0,
+    memMB: int = 1024,
+) -> specs.AppDef:
+    assert replicas > 0, "replicas must be > 0"
+    assert workers_per_replica > 0, "workers_per_replica must be > 0"
+
+    env = env or {}
+
+    # Enable logging for PyTorch, torchelastic and Rust.
+    env.setdefault("TORCH_CPP_LOG_LEVEL", "INFO")
+    env.setdefault("LOGLEVEL", "INFO")
+    env.setdefault("RUST_BACKTRACE", "1")
+
+    # Enable colored logging for torchft Rust logger.
+    env.setdefault("CLICOLOR_FORCE", "1")
+
+    # Set lighthouse address for replicas
+    # This must be run externally
+    env.setdefault(
+        "TORCHFT_LIGHTHOUSE",
+        os.environ.get("TORCHFT_LIGHTHOUSE", f"http://localhost:29510"),
+    )
+
+    # Disable CUDA for CPU-only jobs
+    env.setdefault("CUDA_VISIBLE_DEVICES", "")
+
+    # Disable XPU for CPU-only jobs
+    env.setdefault("XPU_VISIBLE_DEVICES", "")
+
+    roles = []
+    for replica_id in range(replicas):
+        cmd = [
+            f"--master_port={29600+replica_id}",
+            "--nnodes=1",
+            f"--nproc_per_node={workers_per_replica}",
+            f"--max_restarts={max_restarts}",
+        ]
+        if script:
+            cmd += [script]
+        cmd += list(script_args)
+
+        roles.append(
+            specs.Role(
+                name=f"replica_{replica_id}",
+                image=image,
+                min_replicas=workers_per_replica,
+                num_replicas=workers_per_replica,
+                resource=specs.resource(cpu=cpu, gpu=gpu, memMB=memMB, h=h),
+                max_retries=0,
+                env={
+                    "REPLICA_GROUP_ID": str(replica_id),
+                    "NUM_REPLICA_GROUPS": str(replicas),
+                    **env,
+                },
+                entrypoint="torchrun",
+                args=cmd,
+            )
+        )
+
+    return specs.AppDef(
+        name="torchft",
+        roles=roles,
+    )

torchft/utils.py

@@ -0,0 +1,67 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Utility functions for TorchFT.
+"""
+
+from contextlib import nullcontext
+from typing import Any, Optional, Union
+
+import torch
+
+
+def get_stream_context(
+    stream: Optional[torch.Stream],
+) -> Union[torch.cuda.StreamContext, torch.xpu.StreamContext, nullcontext[None]]:
+    """
+    Get the appropriate stream context for the given stream.
+
+    This function provides a unified way to handle stream contexts across different
+    accelerator types (CUDA, XPU).
+
+    Args:
+        stream: The stream to create a context for. If None, returns nullcontext.
+
+    Returns:
+        The appropriate stream context for the accelerator type, or nullcontext
+        if stream is None or no accelerator is available.
+    """
+    if stream is not None:
+        if torch.cuda.is_available():
+            # pyre-fixme[6]: Expected `Optional[streams.Stream]` but got `_C.Stream`
+            return torch.cuda.stream(stream)
+        elif torch.xpu.is_available():
+            # pyre-fixme[6]: Expected `Optional[streams.Stream]` but got `_C.Stream`
+            return torch.xpu.stream(stream)
+        else:
+            return nullcontext()
+    else:
+        return nullcontext()
+
+
+def record_event() -> None:
+    """
+    Record an event in the current stream.
+
+    This function provides a unified way to record events across different
+    accelerator types (CUDA, XPU).
+    """
+    if torch.xpu.is_available():
+        torch.xpu.current_stream().record_event(torch.xpu.Event())
+    else:
+        torch.cuda.current_stream().record_event(torch.cuda.Event(interprocess=True))
+
+
+def synchronize() -> None:
+    """
+    This function provides a unified way to synchronize current stream across different
+    accelerator types (CUDA, XPU).
+    """
+    if torch.cuda.is_available():
+        torch.cuda.current_stream().synchronize()
+    elif torch.xpu.is_available():
+        torch.xpu.current_stream().synchronize()

torchft/work.py

@@ -0,0 +1,26 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from contextlib import nullcontext
+from datetime import timedelta
+from typing import Optional
+
+import torch
+import torch.distributed as dist
+
+
+class _DummyWork(dist._Work):
+    def __init__(self, result: object) -> None:
+        super().__init__()
+        self.result_ = result
+        self.future_: torch.futures.Future[object] = torch.futures.Future()
+        self.future_.set_result(result)
+
+    def wait(self, timeout: Optional[timedelta] = None) -> bool:
+        return True
+
+    def get_future(self) -> torch.futures.Future[object]:
+        return self.future_

torchft_nightly-2026.1.3.dist-info/METADATA

@@ -0,0 +1,308 @@
+Metadata-Version: 2.4
+Name: torchft-nightly
+Version: 2026.1.3
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: torch>=2.7
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.39.0
+Requires-Dist: opentelemetry-sdk>=1.39.0
+Requires-Dist: opentelemetry-api>=1.39.0
+Requires-Dist: pytest==8.3.4 ; extra == 'dev'
+Requires-Dist: pytest-timeout ; extra == 'dev'
+Requires-Dist: parameterized ; extra == 'dev'
+Requires-Dist: expecttest ; extra == 'dev'
+Requires-Dist: numpy ; extra == 'dev'
+Requires-Dist: torchx-nightly ; extra == 'dev'
+Requires-Dist: lintrunner ; extra == 'dev'
+Requires-Dist: lintrunner-adapters ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://docs.pytorch.org/torchft
+Project-URL: Issues, https://github.com/pytorch/torchft/issues
+Project-URL: Repository, https://github.com/pytorch/torchft
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./media/torchft_logo_dark.svg">
+    <img width="55%" src="./media/torchft_logo.svg" alt="torchft">
+  </picture>
+</p>
+
+<h3 align="center">
+Easy Per Step Fault Tolerance for PyTorch
+</h3>
+
+<p align="center">
+  | <a href="https://pytorch.org/torchft/"><b>Documentation</b></a>
+  | <a href="https://github.com/pytorch/torchft/blob/main/media/fault_tolerance_poster.pdf"><b>Poster</b></a>
+  | <a href="https://docs.google.com/document/d/1OZsOsz34gRDSxYXiKkj4WqcD9x0lP9TcsfBeu_SsOY4/edit"><b>Design Doc</b></a>
+  |
+</p>
+<p align="center">
+  <a href="https://pypi.org/project/torchft-nightly/"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/torchft-nightly"></a>
+</p>
+
+---
+
+This repository implements techniques for doing a per-step fault tolerance so
+you can keep training if errors occur without interrupting the entire training
+job.
+
+[This is based on the large scale training techniques presented at PyTorch
+Conference 2024.](./media/fault_tolerance_poster.pdf)
+
+## Overview
+
+torchft is designed to provide the primitives required to implement fault
+tolerance in any application/train script as well as the primitives needed to
+implement custom fault tolerance strategies.
+
+Out of the box, torchft provides the following algorithms:
+
+* Fault Tolerant DDP
+* Fault Tolerant HSDP: fault tolerance across the replicated dimension with any mix of FSDP/TP/etc across the other dimensions.
+* LocalSGD
+* DiLoCo
+
+To implement these, torchft provides some key reusable components:
+
+1. Coordination primitives that can determine which workers are healthy via
+  heartbeating on a per-step basis
+2. Fault tolerant ProcessGroup implementations that report errors sanely and be
+  reinitialized gracefully.
+3. Checkpoint transports that can be used to do live recovery from a healthy
+  peer when doing scale up operations.
+
+The following component diagram shows the high level components and how they
+relate to each other:
+
+![Component Diagram](./media/overview.mmd.svg)
+
+See [torchft's documentation](https://pytorch.org/torchft) for more details.
+
+## Examples
+
+### torchtitan (Fault Tolerant HSDP)
+
+torchtitan provides an out of the box fault tolerant HSDP training loop built on
+top of torchft that can be used to train models such as Llama 3 70B.
+
+It also serves as a good example of how you can integrate torchft into your own training script for use with HSDP.
+
+See [torchtitan's documentation for end to end usage](https://github.com/pytorch/torchtitan/blob/main/docs/torchft.md).
+
+### Fault Tolerant DDP
+
+We have a minimal DDP train loop that highlights all of the key components in torchft.
+
+See [train_ddp.py](./train_ddp.py) for more info.
+
+
+### DiLoCo
+
+LocalSGD and DiLoCo are currently experimental.
+
+See
+[the diloco_train_loop/local_sgd_train_loop tests](./torchft/local_sgd_integ_test.py)
+for an example on how to integrate these algorithms into your training loop.
+
+
+## Design
+
+torchft is designed to allow for fault tolerance when using training with replicated weights such as in DDP or HSDP (FSDP with DDP).
+
+See the [design doc](https://docs.google.com/document/d/1OZsOsz34gRDSxYXiKkj4WqcD9x0lP9TcsfBeu_SsOY4/edit) for the most detailed explanation.
+
+### Lighthouse
+
+torchft implements a lighthouse server that coordinates across the different
+replica groups and then a per replica group manager and fault tolerance library
+that can be used in a standard PyTorch training loop.
+
+This allows for membership changes at the training step granularity which can
+greatly improve efficiency by avoiding stopping the world training on errors.
+
+![Lighthouse Diagram](./media/torchft-overview.png)
+
+### Fault Tolerant HSDP Algorithm
+
+torchft provides an implementation of a fault tolerant HSDP/DDP algorithm. The
+following diagram shows the high level operations that need to happen in the
+train loop to ensure everything stays consistent during a healing operation.
+
+![HSDP Diagram](./media/hsdp_train_loop.png)
+
+See the design doc linked above for more details.
+
+## Installing from PyPI
+
+We have nighty builds available at https://pypi.org/project/torchft-nightly/
+
+To install torchft with minimal dependencies you can run:
+
+```sh
+pip install torchft-nightly
+```
+
+If you want all development dependencies you can install:
+
+```sh
+pip install torchft-nightly[dev]
+```
+
+## Installing from Source
+
+### Prerequisites
+
+Before proceeding, ensure you have the following installed:
+
+- Rust (with necessary dependencies)
+- `protobuf-compiler` and the corresponding development package for Protobuf.
+- PyTorch 2.7 RC+ or Nightly
+
+Note that the Rust versions available in many conda environments may be outdated. To install the latest version of Rust, we recommend downloading it directly from the official website as shown in the below command:
+```sh
+curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+```
+
+To install the required packages on a Debian-based system (such as Ubuntu) using apt, run:
+
+```sh
+sudo apt install protobuf-compiler libprotobuf-dev
+```
+
+or for a Red Hat-based system, run:
+
+```sh
+sudo dnf install protobuf-compiler protobuf-devel
+```
+
+### Installation
+
+```sh
+pip install .
+```
+
+This uses pyo3+maturin to build the package, you'll need maturin installed.
+
+If the installation command fails to invoke `cargo update` due to an inability to fetch the manifest, it may be caused by the `proxy`, `proxySSLCert`, and `proxySSLKey` settings in your .`gitconfig` file affecting the `cargo` command. To resolve this issue, try temporarily removing these fields from your `.gitconfig` before running the installation command.
+
+To install in editable mode w/ the Rust extensions and development dependencies, you can use the normal pip install command:
+
+```sh
+pip install -e '.[dev]'
+```
+
+## Usage
+
+### Lighthouse
+
+The lighthouse is used for fault tolerance across replicated workers (DDP/FSDP)
+when using synchronous training.
+
+You can start a lighthouse server by running:
+
+```sh
+RUST_BACKTRACE=1 torchft_lighthouse --min_replicas 1 --quorum_tick_ms 100 --join_timeout_ms 10000
+```
+
+### Example Training Loop (DDP)
+
+See [train_ddp.py](./train_ddp.py) for the full example.
+
+Invoke with:
+
+```sh
+TORCHFT_LIGHTHOUSE=http://localhost:29510 torchrun --master_port 29501 --nnodes 1 --nproc_per_node 1 train_ddp.py
+```
+
+train.py:
+
+```py
+from torchft import Manager, DistributedDataParallel, Optimizer, ProcessGroupGloo
+
+manager = Manager(
+    pg=ProcessGroupGloo(),
+    load_state_dict=...,
+    state_dict=...,
+)
+
+m = nn.Linear(2, 3)
+m = DistributedDataParallel(manager, m)
+optimizer = Optimizer(manager, optim.AdamW(m.parameters()))
+
+for i in range(1000):
+    batch = torch.rand(2, 2, device=device)
+
+    optimizer.zero_grad()
+
+    out = m(batch)
+    loss = out.sum()
+
+    loss.backward()
+
+    optimizer.step()
+```
+
+### Running DDP
+
+After starting the lighthouse server by running:
+
+```sh
+RUST_BACKTRACE=1 torchft_lighthouse --min_replicas 1 --quorum_tick_ms 100 --join_timeout_ms 10000
+```
+
+A test DDP script can be launched with torchX with:
+
+```sh
+torchx run
+```
+
+Or Diloco with:
+
+```sh
+USE_STREAMING=True torchx run ./torchft/torchx.py:hsdp --script='train_diloco.py'
+```
+
+See [.torchxconfig](.torchxconfig), [torchx.py](./torchft/torchx.py) and the [torchX documentation](https://pytorch.org/torchx/latest/) to understand how DDP is being ran.
+
+`torchx.py` could also launch HSDP jobs when `workers_per_replica` is set > 1, if the training script supports it. For an example HSDP training implementation with torchFT enabled, see [torchtitan](https://github.com/pytorch/torchtitan).
+
+Alternatively, to test on a node with two GPUs, you can launch two replica groups running  [train_ddp.py](./train_ddp.py) by:
+
+On shell 1 (one replica groups starts initial training):
+```sh
+export REPLICA_GROUP_ID=0
+export NUM_REPLICA_GROUPS=2
+
+CUDA_VISIBLE_DEVICES=0 TORCHFT_LIGHTHOUSE=http://localhost:29510 torchrun --master_port=29600 --nnodes=1 --nproc_per_node=1 -- train_ddp.py
+```
+
+On shell 2 (a second replica group joins):
+```sh
+export REPLICA_GROUP_ID=1
+export NUM_REPLICA_GROUPS=2
+
+CUDA_VISIBLE_DEVICES=1 TORCHFT_LIGHTHOUSE=http://localhost:29510 torchrun --master_port=29601 --nnodes=1 --nproc_per_node=1 -- train_ddp.py
+```
+
+By observing the outputs from both shells, you should observe process group reconfiguration and live checkpoint recovery.
+
+### Example Parameter Server
+
+torchft has a fault tolerant parameter server implementation built on it's
+reconfigurable ProcessGroups. This does not require/use a Lighthouse server.
+
+See [parameter_server_test.py](./torchft/parameter_server_test.py) for an example.
+
+## Contributing
+
+We welcome PRs! See the [CONTRIBUTING](./CONTRIBUTING.md) file.
+
+## License
+
+torchft is BSD 3-Clause licensed. See [LICENSE](./LICENSE) for more details.
+

torchft_nightly-2026.1.3.dist-info/RECORD

@@ -0,0 +1,61 @@
+torchft/__init__.py,sha256=OGvxyNeEBOM---9FsnapJcyqH3KB0GnJ9mGhbr-jsjw,915
+torchft/_test/diloco_trainer.py,sha256=r4_LJRzkluRipies39NyyjMb3sEG4JO8hmFJlrdR7ds,9648
+torchft/_test/managed_work_test.py,sha256=28t-b5EaQ4DSFFvuzipq_ox1tmkTrVOWKNADWFf3AbU,11711
+torchft/_test_utils.py,sha256=Hlf_g2rUbFxCI_VskDDZgn9MdvqzPj6VFsNZXWQ07Z4,3260
+torchft/_torchft.cpython-310-x86_64-linux-gnu.so,sha256=X0DHEKq_bCBvmROrOudqRZ6tiqix98zcNEU8_2KKuy8,6832056
+torchft/_torchft.pyi,sha256=WqJlm5dsMT1G8h7iofyZNhvRttmDZpKBuw5GrbeRO-0,2953
+torchft/checkpointing/__init__.py,sha256=-Bottyor1P4u9Fd-yYGpvWKrPMc7V0wuF25-EUjdS04,528
+torchft/checkpointing/_rwlock.py,sha256=yVJGo3pXRTwFb3O5WoaIiz6_gJyrW-I5J5TtSeK53n8,4533
+torchft/checkpointing/_serialization.py,sha256=MU9aYF0xAN1hDXqjZNdUDrnwgDkq3XGFhPtkvzy-CR0,1068
+torchft/checkpointing/http_transport.py,sha256=mtmxi9-1rVRHom_9RoZyrHY5Nv2AAW9F2KGwG_GkfJE,10282
+torchft/checkpointing/http_transport_bench.py,sha256=Uo-GTndb1hDz6vzIoxWPNO0aH82uZFaBdpdLsQKCDPY,1892
+torchft/checkpointing/http_transport_test.py,sha256=c35Hy7gCggg6p9Ml2gf1cEXCG4lsVi8hl7gI7KON2xs,4606
+torchft/checkpointing/pg_transport.py,sha256=hIESpx6lEhZSQLYYPg5CHuMvSDezBxLGY-M3HQplP-s,9742
+torchft/checkpointing/pg_transport_bench.py,sha256=VTlnDUmcl4FWNPFAk8O0XqbRK7BnUwIBbPGus_6eDpw,3074
+torchft/checkpointing/pg_transport_test.py,sha256=imFArrK285gICgLJbm9136zmYSO8-XVrhWI6Nqf13Rs,3678
+torchft/checkpointing/rwlock_test.py,sha256=E79ah4dQMMMWBoTOzBhlzru8tRcSTYKQrI4HOJ6TRGQ,1155
+torchft/checkpointing/transport.py,sha256=2mUf3_xtL-IeE90ZrRWAvvFmJSctPUXPnUYOi47PqeQ,2013
+torchft/checkpointing/transport_test.py,sha256=BTKYMNKqkP3NO1PkapxyNVQP0HmgRMze-SVOSslE-Hs,5029
+torchft/collectives.py,sha256=-UXCWzHE2k6TKsj1D34on-HcxgAP-Tl9tGc2rFM05vk,14528
+torchft/collectives_test.py,sha256=QpqosipNB-Z0LlgUfsoKY6ZBCZcZZ11eRsyLdtUJ46Y,6829
+torchft/coordination.py,sha256=E2nkxPMILaQneDM9VhwvU4GYWlYHEEt81HBVLyWDBUU,964
+torchft/coordination_test.py,sha256=yFkXxL8PVrf73viGEHQpv8c-N1RmfyHen_ArokpclfA,770
+torchft/data.py,sha256=cCtlKPcM-djU73sNq6wld9jBjkuvyLUjgdYrn8UT_jo,2528
+torchft/data_test.py,sha256=ATiE8XPNjNbFDCCsmKCireUU-EnUnqn9vRm6td8w86s,1051
+torchft/ddp.py,sha256=bE46JK2-yrjM7fnjBCXXi6v0smmuG_uRX2sOsNh91Zw,3389
+torchft/ddp_test.py,sha256=SQZFWkPqB1ejw-DJpwaEiHKxUj0Afx_QNLX7kjBjAgc,1867
+torchft/diloco_regression_test.py,sha256=t1gLcc4m55ujM3M-PTWGuYLSwY9BCgojafUcWY80mC8,25664
+torchft/examples/slurm/README.md,sha256=l8cRSpy_kCUWInKYSx78-rYuMjUCxXKX5oFbI81ksKc,891
+torchft/examples/slurm/punisher.py,sha256=Cp4oWrh8Zp4ZAg_MuT1e2BGJLdczlLm4XkQQtQQbMI4,2655
+torchft/examples/slurm/runner.py,sha256=rsYv1bBsC-uvxTT-1Xu6dOV6rKevXbPXFYe7lYtOrCo,6005
+torchft/fsdp_test.py,sha256=mxIa6-y0Xs1JKph8zkireITd1VMj_vbn3vYT-x3Ns-k,3543
+torchft/futures.py,sha256=5VpK99LthFJw0Kiwd99M9gebpp5xGTtmUg25Lmos9MM,11341
+torchft/futures_test.py,sha256=gN5Ud68v0s62Lbs2h3q-VOUsNAvZ2Lu6yDYMS4nwvR4,4582
+torchft/http.py,sha256=SmoBdLMAL8JatoTQut7JsNK9x7QTIS8mR5PQQCV9d-w,407
+torchft/lighthouse_test.py,sha256=d686G7J5Ax8BU37ArONNHOi7b4udGRUhAj4pIhoznzA,5474
+torchft/local_sgd.py,sha256=giYvBZT_MkU-Q0u_OhxF5p6yavWGDAVrQYsM_rteCpk,29440
+torchft/local_sgd_integ_test.py,sha256=mCbNUpBXEeYhhOYhzaBCje1W-AYs7Ifz3vGA_4b8UA8,20230
+torchft/local_sgd_test.py,sha256=SQpl2fanta0MDzAsKbWVw7SlsgTNJdUui7b7wao5YPk,11352
+torchft/manager.py,sha256=KxSZvob05UsiyzkDnIiP9uHlLwZptDmlGr3yfScZatU,50900
+torchft/manager_integ_test.py,sha256=JMzOk80p8X1-O3t2yEb_DH18Hrv2yK4QFbHJCJylj0I,20586
+torchft/manager_test.py,sha256=d42XKVS5bZFHLszNI1tGfHIxL3tN3ytOYqUwZJ7RfKs,33818
+torchft/multiprocessing.py,sha256=AcaakPRd7LSIBP_MvEdtcU3BxIa_LOplEw-vApGNRxI,1116
+torchft/multiprocessing_dummy_context.py,sha256=DXi5iRZWD_N2PETEj0JNte10znyEljCi6sLci9MQyyw,3893
+torchft/multiprocessing_test.py,sha256=JnHcO48NBYOuPwCa37KzIZg6CgBcmRRAhZsA2WqapK0,1518
+torchft/optim.py,sha256=iBJhywVjG9-0490may2PZbEdhvYrbVjsyNOkrkdMPYg,1948
+torchft/optim_test.py,sha256=oA9t83t1beMAWml2Zs0MkmdKJArpSYK7OQ14gkVCpYU,1495
+torchft/otel.py,sha256=gyaSxmNppiPeZSfjIfe42JILYWj0Uw_1Ir-zEI2AF4c,4241
+torchft/parameter_server.py,sha256=fQ4pg8dDGSgkFGsOu36k1-zps0s71EIF5B-wSgXgGRE,6000
+torchft/parameter_server_test.py,sha256=0Yk_6vG2sf3dC8g8OFSSpcuwmJa6yNDwh7xRweUHFzc,1305
+torchft/process_group.py,sha256=sLbmHShafhz4711IunfLTUWP00E1QbbXVfEKumrJACU,69988
+torchft/process_group_test.py,sha256=qHijH_pzca35VClth5aXT_tCgY3ZIxwoFH_UHY2qk5Q,34506
+torchft/quantization.py,sha256=EAIxzdP6AX-c8mEFfyAju11K3tUde1Y4urTrnNYu2n8,24074
+torchft/quantization_test.py,sha256=sRHV4oJJAR8ce9v2nDN2s6LkTr2IQE5lZisHOd2UOPo,4275
+torchft/torchx.py,sha256=dSe0yT5DheWpjl-no6hSFhla_GdB12PaF5uoYBtmsZ8,2493
+torchft/utils.py,sha256=xRPUsm5bIPrWEJeC7_rT0IXr7OO4z864ckLYXDgUpZY,2105
+torchft/work.py,sha256=IlNdLONzoHf_Wu1ujb3tmKn9KytxmGJZH3WE9BBiQMw,776
+torchft_nightly-2026.1.3.dist-info/METADATA,sha256=VtFfDcAo04ZFIh8AgLqvu3XBHEVMh739Dxne5ffX6dg,9888
+torchft_nightly-2026.1.3.dist-info/WHEEL,sha256=pb4kzB25058gQK4V2ufO4qOywKBWVlask3GAY9yVdn4,109
+torchft_nightly-2026.1.3.dist-info/entry_points.txt,sha256=xTOOuXiCVovuQMX7rEX77rnYtRwIwDb1rYiMSWygtqM,70
+torchft_nightly-2026.1.3.dist-info/licenses/LICENSE,sha256=yXcfhd3XpfByVfZX2WlDmfjdj8lytYNDpjowg2qzFuc,1641
+torchft_nightly-2026.1.3.dist-info/RECORD,,

torchft_nightly-2026.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_24_x86_64

torchft_nightly-2026.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+torchft_lighthouse=torchft._torchft:lighthouse_main