fix: stub files contained HF redirect pages instead of Python

curl without -L saved the 307 redirect body. Re-downloaded with
redirect-following and validated all 19 files with ast.parse.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

flash_attn_stub/flash_attn/__init__.py

@@ -1 +1,191 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/flash_attn_stub%2Fflash_attn%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fflash_attn_stub%2Fflash_attn%2F__init__.py=&etag=%22e8154a003b387b4a013f13f81e6b1d904ed91395%22
+"""flash_attn stub – implements flash attention API using torch SDPA.
+
+This replaces the real flash_attn package on systems where it cannot be compiled
+(e.g. ZeroGPU with PyTorch 2.10+cu128 and no matching wheel).
+All functions accept the same signatures as flash_attn 2.x and delegate to
+torch.nn.functional.scaled_dot_product_attention.
+"""
+import torch
+import torch.nn.functional as F
+
+
+def _sdpa(q, k, v, causal=False, softmax_scale=None):
+    """Apply SDPA. q/k/v are (B, H, L, D)."""
+    return F.scaled_dot_product_attention(
+        q, k, v,
+        is_causal=causal,
+        scale=softmax_scale,
+    )
+
+
+# ---------- non-varlen ----------
+
+def flash_attn_func(q, k, v, dropout_p=0.0, softmax_scale=None, causal=False,
+                    window_size=(-1, -1), softcap=0.0, alibi_slopes=None,
+                    deterministic=False, return_attn_probs=False):
+    """q/k/v: (B, L, H, D) -> out: (B, L, H, D)"""
+    # Permute to (B, H, L, D) for SDPA
+    q2 = q.transpose(1, 2)
+    k2 = k.transpose(1, 2)
+    v2 = v.transpose(1, 2)
+    out = _sdpa(q2, k2, v2, causal=causal, softmax_scale=softmax_scale)
+    out = out.transpose(1, 2)  # back to (B, L, H, D)
+    return out
+
+
+def flash_attn_qkvpacked_func(qkv, dropout_p=0.0, softmax_scale=None, causal=False,
+                               window_size=(-1, -1), softcap=0.0, alibi_slopes=None,
+                               deterministic=False, return_attn_probs=False):
+    """qkv: (B, L, 3, H, D) -> out: (B, L, H, D)"""
+    q, k, v = qkv.unbind(dim=2)
+    return flash_attn_func(q, k, v, dropout_p=dropout_p, softmax_scale=softmax_scale,
+                           causal=causal)
+
+
+def flash_attn_kvpacked_func(q, kv, dropout_p=0.0, softmax_scale=None, causal=False,
+                              window_size=(-1, -1), softcap=0.0, alibi_slopes=None,
+                              deterministic=False, return_attn_probs=False):
+    """q: (B, Lq, H, D), kv: (B, Lk, 2, H, D) -> out: (B, Lq, H, D)"""
+    k, v = kv.unbind(dim=2)
+    return flash_attn_func(q, k, v, dropout_p=dropout_p, softmax_scale=softmax_scale,
+                           causal=causal)
+
+
+# ---------- varlen ----------
+
+def _varlen_sdpa(q, k, v, cu_seqlens_q, cu_seqlens_k, max_seqlen_q, max_seqlen_k,
+                 causal=False, softmax_scale=None):
+    """
+    q: (total_q, H, D), k: (total_k, H, D), v: (total_k, H, D)
+    cu_seqlens_q/k: (batch+1,) int32
+    Returns: (total_q, H, D)
+    """
+    batch = cu_seqlens_q.shape[0] - 1
+    H = q.shape[1]
+    D = q.shape[2]
+
+    # Fast path: all seqlens are equal (common case)
+    cu_q = cu_seqlens_q.tolist()
+    cu_k = cu_seqlens_k.tolist()
+
+    all_equal = True
+    sq0 = cu_q[1] - cu_q[0]
+    sk0 = cu_k[1] - cu_k[0]
+    for i in range(1, batch):
+        if cu_q[i + 1] - cu_q[i] != sq0 or cu_k[i + 1] - cu_k[i] != sk0:
+            all_equal = False
+            break
+
+    if all_equal and sq0 == max_seqlen_q and sk0 == max_seqlen_k:
+        # Reshape directly – no padding needed
+        q2 = q.reshape(batch, sq0, H, D).transpose(1, 2)   # (B, H, Lq, D)
+        k2 = k.reshape(batch, sk0, H, D).transpose(1, 2)
+        v2 = v.reshape(batch, sk0, H, D).transpose(1, 2)
+        out = _sdpa(q2, k2, v2, causal=causal, softmax_scale=softmax_scale)
+        return out.transpose(1, 2).reshape(-1, H, D)
+
+    # Slow path: unequal lengths – pad, compute, then gather
+    q_padded = q.new_zeros(batch, max_seqlen_q, H, D)
+    k_padded = k.new_zeros(batch, max_seqlen_k, H, D)
+    v_padded = v.new_zeros(batch, max_seqlen_k, H, D)
+
+    for i in range(batch):
+        sq = cu_q[i + 1] - cu_q[i]
+        sk = cu_k[i + 1] - cu_k[i]
+        q_padded[i, :sq] = q[cu_q[i]:cu_q[i + 1]]
+        k_padded[i, :sk] = k[cu_k[i]:cu_k[i + 1]]
+        v_padded[i, :sk] = v[cu_k[i]:cu_k[i + 1]]
+
+    # Create attention mask for padding
+    q_mask = torch.arange(max_seqlen_q, device=q.device).unsqueeze(0)  # (1, Lq)
+    k_mask = torch.arange(max_seqlen_k, device=k.device).unsqueeze(0)  # (1, Lk)
+    q_lens = torch.tensor([cu_q[i + 1] - cu_q[i] for i in range(batch)],
+                          device=q.device).unsqueeze(1)  # (B, 1)
+    k_lens = torch.tensor([cu_k[i + 1] - cu_k[i] for i in range(batch)],
+                          device=k.device).unsqueeze(1)  # (B, 1)
+    # (B, 1, 1, Lk) – True where valid
+    attn_mask = (k_mask < k_lens).unsqueeze(1).unsqueeze(2)
+    # Also mask out query positions that are padding (their output is ignored anyway)
+    # Use float mask: -inf for invalid positions
+    attn_bias = torch.zeros(batch, 1, max_seqlen_q, max_seqlen_k,
+                            device=q.device, dtype=q.dtype)
+    attn_bias.masked_fill_(~attn_mask, float('-inf'))
+
+    if causal:
+        causal_mask = torch.triu(
+            torch.ones(max_seqlen_q, max_seqlen_k, device=q.device, dtype=torch.bool),
+            diagonal=1
+        )
+        attn_bias.masked_fill_(causal_mask.unsqueeze(0).unsqueeze(0), float('-inf'))
+
+    q2 = q_padded.transpose(1, 2)  # (B, H, Lq, D)
+    k2 = k_padded.transpose(1, 2)
+    v2 = v_padded.transpose(1, 2)
+
+    out = F.scaled_dot_product_attention(q2, k2, v2, attn_mask=attn_bias,
+                                         scale=softmax_scale)
+    out = out.transpose(1, 2)  # (B, Lq, H, D)
+
+    # Gather results back to packed format
+    parts = []
+    for i in range(batch):
+        sq = cu_q[i + 1] - cu_q[i]
+        parts.append(out[i, :sq])  # (sq, H, D)
+    return torch.cat(parts, dim=0)
+
+
+def flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_k,
+                           max_seqlen_q, max_seqlen_k,
+                           dropout_p=0.0, softmax_scale=None, causal=False,
+                           window_size=(-1, -1), softcap=0.0, alibi_slopes=None,
+                           deterministic=False, return_attn_probs=False,
+                           block_table=None):
+    """q/k/v: (total, H, D) -> out: (total_q, H, D)"""
+    return _varlen_sdpa(q, k, v, cu_seqlens_q, cu_seqlens_k,
+                        max_seqlen_q, max_seqlen_k,
+                        causal=causal, softmax_scale=softmax_scale)
+
+
+def flash_attn_varlen_qkvpacked_func(qkv, cu_seqlens, max_seqlen,
+                                      dropout_p=0.0, softmax_scale=None, causal=False,
+                                      window_size=(-1, -1), softcap=0.0,
+                                      alibi_slopes=None, deterministic=False,
+                                      return_attn_probs=False):
+    """qkv: (total, 3, H, D) -> out: (total, H, D)"""
+    q, k, v = qkv.unbind(dim=1)
+    return _varlen_sdpa(q, k, v, cu_seqlens, cu_seqlens,
+                        max_seqlen, max_seqlen,
+                        causal=causal, softmax_scale=softmax_scale)
+
+
+def flash_attn_varlen_kvpacked_func(q, kv, cu_seqlens_q, cu_seqlens_k,
+                                     max_seqlen_q, max_seqlen_k,
+                                     dropout_p=0.0, softmax_scale=None, causal=False,
+                                     window_size=(-1, -1), softcap=0.0,
+                                     alibi_slopes=None, deterministic=False,
+                                     return_attn_probs=False):
+    """q: (total_q, H, D), kv: (total_k, 2, H, D) -> out: (total_q, H, D)"""
+    k, v = kv.unbind(dim=1)
+    return _varlen_sdpa(q, k, v, cu_seqlens_q, cu_seqlens_k,
+                        max_seqlen_q, max_seqlen_k,
+                        causal=causal, softmax_scale=softmax_scale)
+
+
+# ---------- with_kvcache (used by some SAM2 code paths) ----------
+
+def flash_attn_with_kvcache(q, k_cache, v_cache, k=None, v=None,
+                            rotary_cos=None, rotary_sin=None,
+                            cache_seqlens=None, cache_batch_idx=None,
+                            block_table=None, softmax_scale=None, causal=False,
+                            window_size=(-1, -1), softcap=0.0,
+                            rotary_interleaved=True, alibi_slopes=None,
+                            num_splits=0, return_softmax_lse=False):
+    """Simplified kv-cache attention fallback."""
+    # Combine current k/v with cache if provided
+    if k is not None:
+        k_full = torch.cat([k_cache, k], dim=1)
+        v_full = torch.cat([v_cache, v], dim=1)
+    else:
+        k_full = k_cache
+        v_full = v_cache
+    return flash_attn_func(q, k_full, v_full, softmax_scale=softmax_scale, causal=causal)

kaolin_stub/kaolin/__init__.py

@@ -1 +1,2 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/kaolin_stub%2Fkaolin%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fkaolin_stub%2Fkaolin%2F__init__.py=&etag=%22b33d127162fbf6be3b4108393add91478bb521bc%22
+"""Kaolin stub - minimum API for SAM3D."""
+from . import ops, render, visualize

kaolin_stub/kaolin/ops/__init__.py

@@ -1 +1,2 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/kaolin_stub%2Fkaolin%2Fops%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fkaolin_stub%2Fkaolin%2Fops%2F__init__.py=&etag=%227f1d5481770b3ffa39effdbf052adca321305592%22
+"""Kaolin ops stub."""
+from . import mesh

kaolin_stub/kaolin/ops/mesh.py

@@ -1 +1 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/kaolin_stub%2Fkaolin%2Fops%2Fmesh.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fkaolin_stub%2Fkaolin%2Fops%2Fmesh.py=&etag=%22d225c551eeaf6ff221c55bdc3521cb0a49ba8db8%22
+"""Stub."""

kaolin_stub/kaolin/render/__init__.py

@@ -1 +1,2 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/kaolin_stub%2Fkaolin%2Frender%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fkaolin_stub%2Fkaolin%2Frender%2F__init__.py=&etag=%228b7c03b43ec0b7f5d8fa5812a970190761e6ec80%22
+"""Kaolin render stub."""
+from . import camera

kaolin_stub/kaolin/render/camera.py

@@ -1 +1,22 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/kaolin_stub%2Fkaolin%2Frender%2Fcamera.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fkaolin_stub%2Fkaolin%2Frender%2Fcamera.py=&etag=%2297e63314864f4ef5e2d5d3a21971d3a9297ebee3%22
+"""Kaolin camera stub."""
+import torch
+import math
+
+class PinholeIntrinsics:
+    def __init__(self, fov=None, focal_length=None, width=None, height=None, **kwargs):
+        self.fov = fov
+        self.focal_length = focal_length
+        self.width = width
+        self.height = height
+
+class CameraExtrinsics:
+    def __init__(self, view_matrix=None, **kwargs):
+        self.view_matrix = view_matrix
+
+class Camera:
+    def __init__(self, extrinsics=None, intrinsics=None, **kwargs):
+        self.extrinsics = extrinsics
+        self.intrinsics = intrinsics
+    @classmethod
+    def from_args(cls, **kwargs):
+        return cls(**kwargs)

kaolin_stub/kaolin/utils/__init__.py

@@ -1 +1,2 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/kaolin_stub%2Fkaolin%2Futils%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fkaolin_stub%2Fkaolin%2Futils%2F__init__.py=&etag=%2297df528c28d988591233bdc1ef2ba44e78cddf94%22
+"""kaolin.utils stub."""
+from . import testing

kaolin_stub/kaolin/utils/testing.py

@@ -1 +1,4 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/kaolin_stub%2Fkaolin%2Futils%2Ftesting.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fkaolin_stub%2Fkaolin%2Futils%2Ftesting.py=&etag=%2270331aa66fe7f80563073a85d5102d6485e7213f%22
+"""kaolin.utils.testing stub."""
+def check_tensor(tensor, shape=None, dtype=None, device=None, throw=True):
+    """No-op tensor check."""
+    return True

kaolin_stub/kaolin/visualize/__init__.py

@@ -1 +1,4 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/kaolin_stub%2Fkaolin%2Fvisualize%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fkaolin_stub%2Fkaolin%2Fvisualize%2F__init__.py=&etag=%228492fef06d88908029b877d623ab3f9ec746a767%22
+"""Kaolin visualize stub."""
+class IpyTurntableVisualizer:
+    def __init__(self, *a, **kw): pass
+    def show(self, *a, **kw): pass

pytorch3d_stub/pytorch3d/__init__.py

@@ -1 +1,21 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2F__init__.py=&etag=%220be164bba8a444d77ed028c703c53164efa59be1%22
+"""pytorch3d stub package with catch-all for missing submodules."""
+import importlib
+import warnings
+
+__version__ = "0.0.0-stub"
+
+def __getattr__(name):
+    if name.startswith("__") and name.endswith("__"):
+        raise AttributeError(name)
+    # Try importing submodule first
+    try:
+        return importlib.import_module(f".{name}", __name__)
+    except ImportError:
+        pass
+    warnings.warn(f"pytorch3d stub: {name} not implemented", stacklevel=2)
+    class _Dummy:
+        def __init__(self, *a, **kw): pass
+        def __call__(self, *a, **kw): return None
+        def to(self, *a, **kw): return self
+    _Dummy.__name__ = _Dummy.__qualname__ = name
+    return _Dummy

pytorch3d_stub/pytorch3d/renderer/__init__.py

@@ -1 +1,126 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Frenderer%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Frenderer%2F__init__.py=&etag=%224ad1da5bd5d463828d7c2da904e7e130b1644f44%22
+"""pytorch3d.renderer stub with catch-all for missing attributes."""
+import torch
+import math
+import warnings
+
+
+def __getattr__(name):
+    """Catch-all: return a dummy class/function for any missing attribute."""
+    if name.startswith("__") and name.endswith("__"):
+        raise AttributeError(name)
+    warnings.warn(f"pytorch3d.renderer stub: {name} not implemented, returning dummy", stacklevel=2)
+    class _Dummy:
+        def __init__(self, *a, **kw): pass
+        def __call__(self, *a, **kw): return None
+        def to(self, *a, **kw): return self
+        def forward(self, *a, **kw): return None
+    _Dummy.__name__ = _Dummy.__qualname__ = name
+    return _Dummy
+
+
+def look_at_view_transform(dist=1.0, elev=0.0, azim=0.0, degrees=True, eye=None,
+                            at=((0, 0, 0),), up=((0, 1, 0),), device="cpu"):
+    if eye is not None:
+        if not isinstance(eye, torch.Tensor):
+            eye = torch.tensor(eye, dtype=torch.float32, device=device)
+        if eye.dim() == 1:
+            eye = eye.unsqueeze(0)
+    else:
+        elev_r = math.radians(float(elev)) if degrees else float(elev)
+        azim_r = math.radians(float(azim)) if degrees else float(azim)
+        x = dist * math.cos(elev_r) * math.sin(azim_r)
+        y = dist * math.sin(elev_r)
+        z = dist * math.cos(elev_r) * math.cos(azim_r)
+        eye = torch.tensor([[x, y, z]], dtype=torch.float32, device=device)
+    if not isinstance(at, torch.Tensor):
+        at = torch.tensor(at, dtype=torch.float32, device=device)
+    if at.dim() == 1: at = at.unsqueeze(0)
+    if not isinstance(up, torch.Tensor):
+        up = torch.tensor(up, dtype=torch.float32, device=device)
+    if up.dim() == 1: up = up.unsqueeze(0)
+    z_axis = eye - at
+    z_axis = z_axis / z_axis.norm(dim=-1, keepdim=True).clamp(min=1e-8)
+    x_axis = torch.cross(up.expand_as(z_axis), z_axis, dim=-1)
+    x_axis = x_axis / x_axis.norm(dim=-1, keepdim=True).clamp(min=1e-8)
+    y_axis = torch.cross(z_axis, x_axis, dim=-1)
+    R = torch.stack([x_axis, y_axis, z_axis], dim=-1)
+    T = -torch.bmm(R.transpose(1, 2), eye.unsqueeze(-1)).squeeze(-1)
+    return R, T
+
+
+def ray_bundle_to_ray_points(ray_bundle):
+    return None
+
+
+class CamerasBase:
+    pass
+
+
+class PerspectiveCameras(CamerasBase):
+    def __init__(self, focal_length=None, principal_point=None, R=None, T=None,
+                 image_size=None, device="cpu", in_ndc=True, **kwargs):
+        self.device = device
+        self.focal_length = focal_length
+        self.principal_point = principal_point
+        self.R = R if R is not None else torch.eye(3, device=device).unsqueeze(0)
+        self.T = T if T is not None else torch.zeros(1, 3, device=device)
+        self.image_size = image_size
+        self.in_ndc = in_ndc
+    def to(self, device):
+        self.device = device; return self
+
+
+class RasterizationSettings:
+    def __init__(self, image_size=256, blur_radius=0.0, faces_per_pixel=1, **kwargs):
+        self.image_size = image_size; self.blur_radius = blur_radius; self.faces_per_pixel = faces_per_pixel
+
+
+class BlendParams:
+    def __init__(self, sigma=1e-4, gamma=1e-4, background_color=(0.0, 0.0, 0.0)):
+        self.sigma = sigma; self.gamma = gamma; self.background_color = background_color
+
+
+class SoftSilhouetteShader:
+    def __init__(self, blend_params=None):
+        self.blend_params = blend_params or BlendParams()
+
+
+class MeshRasterizer(torch.nn.Module):
+    def __init__(self, cameras=None, raster_settings=None):
+        super().__init__()
+        self.cameras = cameras; self.raster_settings = raster_settings
+    def forward(self, meshes, **kw):
+        raise NotImplementedError("MeshRasterizer stub")
+
+
+class MeshRenderer(torch.nn.Module):
+    def __init__(self, rasterizer=None, shader=None):
+        super().__init__()
+        self.rasterizer = rasterizer; self.shader = shader
+    def forward(self, meshes, **kw):
+        raise NotImplementedError("MeshRenderer stub")
+
+
+class TexturesVertex:
+    def __init__(self, verts_features=None):
+        self.verts_features_list = verts_features if isinstance(verts_features, list) else [verts_features]
+    def to(self, device): return self
+
+
+class TexturesAtlas:
+    def __init__(self, atlas=None, **kw): self.atlas = atlas
+    def to(self, device): return self
+
+
+class TexturesUV:
+    def __init__(self, **kw): pass
+    def to(self, device): return self
+
+
+class HeterogeneousRayBundle:
+    def __init__(self, *a, **kw): pass
+
+
+class RayBundle:
+    def __init__(self, origins=None, directions=None, lengths=None, xys=None, **kw):
+        self.origins = origins; self.directions = directions; self.lengths = lengths; self.xys = xys

pytorch3d_stub/pytorch3d/renderer/camera_utils.py

@@ -1 +1,11 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Frenderer%2Fcamera_utils.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Frenderer%2Fcamera_utils.py=&etag=%22819d1ca667d03548de636a7079ab25e239735d6c%22
+"""pytorch3d.renderer.camera_utils stub."""
+import torch
+
+def camera_to_eye_at_up(camera):
+    """Extract eye, at, up from camera. Minimal stub."""
+    R = camera.R if hasattr(camera, "R") else torch.eye(3).unsqueeze(0)
+    T = camera.T if hasattr(camera, "T") else torch.zeros(1, 3)
+    eye = -torch.bmm(R, T.unsqueeze(-1)).squeeze(-1)
+    at = torch.zeros_like(eye)
+    up = torch.tensor([[0.0, 1.0, 0.0]])
+    return eye, at, up

pytorch3d_stub/pytorch3d/renderer/cameras.py

@@ -1 +1,3 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Frenderer%2Fcameras.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Frenderer%2Fcameras.py=&etag=%2222da58b8bd463e8347effc1530fac0e77313a845%22
+"""pytorch3d.renderer.cameras stub."""
+from pytorch3d.renderer import PerspectiveCameras, CamerasBase
+__all__ = ["PerspectiveCameras", "CamerasBase"]

pytorch3d_stub/pytorch3d/renderer/mesh/__init__.py

@@ -1 +1 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Frenderer%2Fmesh%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Frenderer%2Fmesh%2F__init__.py=&etag=%2254776a5dc4978bdd6adc39d981fe242aaa0327f7%22
+from pytorch3d.renderer import TexturesVertex

pytorch3d_stub/pytorch3d/renderer/mesh/textures.py

@@ -1 +1 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Frenderer%2Fmesh%2Ftextures.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Frenderer%2Fmesh%2Ftextures.py=&etag=%2254776a5dc4978bdd6adc39d981fe242aaa0327f7%22
+from pytorch3d.renderer import TexturesVertex

pytorch3d_stub/pytorch3d/structures/__init__.py

@@ -1 +1,48 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Fstructures%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Fstructures%2F__init__.py=&etag=%221d9561d58a998fb884e75446b8a8417d346bfa9a%22
+"""pytorch3d.structures stub with catch-all."""
+import torch
+import warnings
+
+
+def __getattr__(name):
+    if name.startswith("__") and name.endswith("__"):
+        raise AttributeError(name)
+    warnings.warn(f"pytorch3d.structures stub: {name} not implemented", stacklevel=2)
+    class _Dummy:
+        def __init__(self, *a, **kw): pass
+        def to(self, *a, **kw): return self
+    _Dummy.__name__ = _Dummy.__qualname__ = name
+    return _Dummy
+
+
+class Meshes:
+    def __init__(self, verts=None, faces=None, textures=None):
+        if isinstance(verts, list):
+            self._verts_list = [v if isinstance(v, torch.Tensor) else torch.tensor(v, dtype=torch.float32) for v in verts]
+        elif isinstance(verts, torch.Tensor):
+            self._verts_list = [verts]
+        else:
+            self._verts_list = []
+        if isinstance(faces, list):
+            self._faces_list = [f if isinstance(f, torch.Tensor) else torch.tensor(f, dtype=torch.long) for f in faces]
+        elif isinstance(faces, torch.Tensor):
+            self._faces_list = [faces]
+        else:
+            self._faces_list = []
+        self.textures = textures
+    def verts_list(self): return self._verts_list
+    def faces_list(self): return self._faces_list
+    def verts_packed(self):
+        return torch.cat(self._verts_list, dim=0) if self._verts_list else torch.zeros(0, 3)
+    def faces_packed(self):
+        return torch.cat(self._faces_list, dim=0) if self._faces_list else torch.zeros(0, 3, dtype=torch.long)
+    def num_verts_per_mesh(self):
+        return torch.tensor([v.shape[0] for v in self._verts_list])
+    def __len__(self): return len(self._verts_list)
+
+
+class Pointclouds:
+    def __init__(self, points=None, features=None, normals=None):
+        self.points_list = points if isinstance(points, list) else ([points] if points is not None else [])
+        self.features_list = features if isinstance(features, list) else ([features] if features is not None else [])
+        self.normals_list = normals if isinstance(normals, list) else ([normals] if normals is not None else [])
+    def to(self, device): return self

pytorch3d_stub/pytorch3d/transforms/__init__.py

@@ -1 +1,244 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Ftransforms%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Ftransforms%2F__init__.py=&etag=%22561aad8e8e0e3e6182e3f62283f3cbdd710e4bf8%22
+"""pytorch3d.transforms stub with catch-all."""
+import torch
+import warnings
+
+
+def __getattr__(name):
+    if name.startswith("__") and name.endswith("__"):
+        raise AttributeError(name)
+    warnings.warn(f"pytorch3d.transforms stub: {name} not implemented", stacklevel=2)
+    def _dummy(*a, **kw): return None
+    _dummy.__name__ = name
+    return _dummy
+
+
+def quaternion_to_matrix(quaternions):
+    r, i, j, k = quaternions[..., 0], quaternions[..., 1], quaternions[..., 2], quaternions[..., 3]
+    two_s = 2.0 / (quaternions * quaternions).sum(-1)
+    o = torch.stack([
+        1 - two_s * (j*j + k*k), two_s * (i*j - k*r), two_s * (i*k + j*r),
+        two_s * (i*j + k*r), 1 - two_s * (i*i + k*k), two_s * (j*k - i*r),
+        two_s * (i*k - j*r), two_s * (j*k + i*r), 1 - two_s * (i*i + j*j),
+    ], -1)
+    return o.reshape(quaternions.shape[:-1] + (3, 3))
+
+
+def matrix_to_quaternion(matrix):
+    if matrix.shape[-2:] != (3, 3):
+        raise ValueError(f"Invalid rotation matrix shape {matrix.shape}")
+    batch_dim = matrix.shape[:-2]
+    m00, m01, m02 = matrix[..., 0, 0], matrix[..., 0, 1], matrix[..., 0, 2]
+    m10, m11, m12 = matrix[..., 1, 0], matrix[..., 1, 1], matrix[..., 1, 2]
+    m20, m21, m22 = matrix[..., 2, 0], matrix[..., 2, 1], matrix[..., 2, 2]
+    trace = m00 + m11 + m22
+    qw = torch.sqrt(torch.clamp(trace + 1, min=1e-8)) / 2
+    qx = (m21 - m12) / (4 * qw + 1e-8)
+    qy = (m02 - m20) / (4 * qw + 1e-8)
+    qz = (m10 - m01) / (4 * qw + 1e-8)
+    return torch.stack([qw, qx, qy, qz], dim=-1)
+
+
+def quaternion_multiply(a, b):
+    aw, ax, ay, az = a[..., 0], a[..., 1], a[..., 2], a[..., 3]
+    bw, bx, by, bz = b[..., 0], b[..., 1], b[..., 2], b[..., 3]
+    ow = aw*bw - ax*bx - ay*by - az*bz
+    ox = aw*bx + ax*bw + ay*bz - az*by
+    oy = aw*by - ax*bz + ay*bw + az*bx
+    oz = aw*bz + ax*by - ay*bx + az*bw
+    return torch.stack([ow, ox, oy, oz], dim=-1)
+
+
+def quaternion_invert(quaternion):
+    scaling = torch.tensor([1, -1, -1, -1], dtype=quaternion.dtype, device=quaternion.device)
+    return quaternion * scaling
+
+
+def axis_angle_to_quaternion(axis_angle):
+    """Convert rotations given as axis/angle to quaternions.
+    Args:
+        axis_angle: Rotations given as a vector in axis angle form,
+            as a tensor of shape (..., 3), where the magnitude is
+            the angle turned anticlockwise in radians around the
+            vector's direction.
+    Returns:
+        quaternions with real parts first, as tensor of shape (..., 4).
+    """
+    angles = torch.norm(axis_angle, p=2, dim=-1, keepdim=True)
+    half_angles = angles * 0.5
+    eps = 1e-6
+    small_angles = angles.abs() < eps
+    sin_half = torch.where(small_angles, 0.5 * torch.ones_like(angles), torch.sin(half_angles) / angles)
+    cos_half = torch.where(small_angles, torch.ones_like(angles), torch.cos(half_angles))
+    quaternions = torch.cat([cos_half, axis_angle * sin_half], dim=-1)
+    return quaternions
+
+
+def axis_angle_to_matrix(axis_angle):
+    """Convert rotations given as axis/angle to rotation matrices."""
+    return quaternion_to_matrix(axis_angle_to_quaternion(axis_angle))
+
+
+class Transform3d:
+    def __init__(self, dtype=torch.float32, device="cpu", matrix=None):
+        if matrix is not None:
+            self._matrix = matrix.to(device=device, dtype=dtype)
+            self.device = self._matrix.device
+            self.dtype = self._matrix.dtype
+        else:
+            self._matrix = torch.eye(4, dtype=dtype, device=device).unsqueeze(0)
+            self.device = self._matrix.device
+            self.dtype = dtype
+
+    def get_matrix(self):
+        return self._matrix
+
+    def compose(self, *others):
+        m = self._matrix
+        for o in others:
+            om = o.get_matrix().to(device=m.device, dtype=m.dtype)
+            if om.shape[0] != m.shape[0]:
+                if m.shape[0] == 1:
+                    m = m.expand(om.shape[0], -1, -1)
+                elif om.shape[0] == 1:
+                    om = om.expand(m.shape[0], -1, -1)
+            m = m @ om
+        return Transform3d(matrix=m, device=str(m.device), dtype=m.dtype)
+
+    def transform_points(self, points):
+        if points.dim() == 2:
+            points = points.unsqueeze(0)
+        mat = self._matrix
+        points = points.to(device=mat.device, dtype=mat.dtype)
+        ones = torch.ones(*points.shape[:-1], 1, dtype=mat.dtype, device=mat.device)
+        pts4 = torch.cat([points, ones], dim=-1)
+        m = mat.expand(pts4.shape[0], -1, -1)
+        out = torch.bmm(pts4, m.transpose(-2, -1))
+        return out[..., :3]
+
+    def translate(self, x, y=None, z=None):
+        dev = self._matrix.device
+        dt = self._matrix.dtype
+        if isinstance(x, torch.Tensor) and x.dim() >= 1 and x.shape[-1] == 3:
+            t = x.to(device=dev, dtype=dt)
+        else:
+            t = torch.tensor([[x, y, z]], dtype=dt, device=dev)
+        if t.dim() == 1:
+            t = t.unsqueeze(0)
+        T = torch.eye(4, dtype=dt, device=dev).unsqueeze(0).expand(t.shape[0], -1, -1).clone()
+        T[:, :3, 3] = t
+        new_m = self._matrix @ T
+        return Transform3d(matrix=new_m, device=str(dev), dtype=dt)
+
+    def scale(self, x, y=None, z=None):
+        dev = self._matrix.device
+        dt = self._matrix.dtype
+        if isinstance(x, torch.Tensor):
+            x = x.to(device=dev, dtype=dt)
+            if x.dim() == 0:
+                s = x.expand(3)
+            elif x.shape[-1] == 3:
+                s = x.squeeze()
+            else:
+                s = x.expand(3)
+        else:
+            if y is None: y = x
+            if z is None: z = x
+            s = torch.tensor([x, y, z], dtype=dt, device=dev)
+        if s.dim() == 1:
+            s = s.unsqueeze(0)
+        S = torch.eye(4, dtype=dt, device=dev).unsqueeze(0).expand(s.shape[0], -1, -1).clone()
+        S[:, 0, 0] = s[:, 0]; S[:, 1, 1] = s[:, 1]; S[:, 2, 2] = s[:, 2]
+        new_m = self._matrix @ S
+        return Transform3d(matrix=new_m, device=str(dev), dtype=dt)
+
+    def to(self, device=None, dtype=None):
+        self._matrix = self._matrix.to(device=device, dtype=dtype)
+        self.device = self._matrix.device
+        if dtype is not None:
+            self.dtype = dtype
+        return self
+
+    def inverse(self):
+        inv_m = torch.inverse(self._matrix)
+        return Transform3d(matrix=inv_m, device=str(self._matrix.device), dtype=self._matrix.dtype)
+
+    def rotate(self, R):
+        dev = self._matrix.device
+        dt = self._matrix.dtype
+        R = R.to(device=dev, dtype=dt)
+        if R.dim() == 2:
+            R = R.unsqueeze(0)
+        T = torch.eye(4, dtype=dt, device=dev).unsqueeze(0).expand(R.shape[0], -1, -1).clone()
+        T[:, :3, :3] = R
+        new_m = self._matrix @ T
+        return Transform3d(matrix=new_m, device=str(dev), dtype=dt)
+
+    def stack(self, *others):
+        matrices = [self._matrix] + [o.get_matrix().to(device=self._matrix.device, dtype=self._matrix.dtype) for o in others]
+        stacked = torch.cat(matrices, dim=0)
+        return Transform3d(matrix=stacked, device=str(self._matrix.device), dtype=self._matrix.dtype)
+
+    def clone(self):
+        return Transform3d(matrix=self._matrix.clone(), device=str(self._matrix.device), dtype=self._matrix.dtype)
+
+    def __len__(self):
+        return self._matrix.shape[0]
+
+    def __getitem__(self, index):
+        m = self._matrix[index]
+        if m.dim() == 2:
+            m = m.unsqueeze(0)
+        return Transform3d(matrix=m, device=str(self._matrix.device), dtype=self._matrix.dtype)
+
+
+class Rotate(Transform3d):
+    """Transform3d initialized with a rotation matrix."""
+    def __init__(self, R=None, dtype=torch.float32, device="cpu"):
+        super().__init__(dtype=dtype, device=device)
+        if R is not None:
+            if isinstance(R, torch.Tensor):
+                R = R.to(device=device, dtype=dtype)
+                if R.dim() == 2:
+                    R = R.unsqueeze(0)
+                T = torch.eye(4, dtype=dtype, device=device).unsqueeze(0).expand(R.shape[0], -1, -1).clone()
+                T[:, :3, :3] = R
+                self._matrix = T
+                self.device = self._matrix.device
+
+
+class Translate(Transform3d):
+    """Transform3d initialized with a translation."""
+    def __init__(self, x=0.0, y=0.0, z=0.0, dtype=torch.float32, device="cpu"):
+        super().__init__(dtype=dtype, device=device)
+        if isinstance(x, torch.Tensor):
+            t = x.to(device=device, dtype=dtype)
+            if t.dim() == 1:
+                t = t.unsqueeze(0)
+        else:
+            t = torch.tensor([[x, y, z]], dtype=dtype, device=device)
+        T = torch.eye(4, dtype=dtype, device=device).unsqueeze(0).expand(t.shape[0], -1, -1).clone()
+        T[:, :3, 3] = t
+        self._matrix = T
+        self.device = self._matrix.device
+
+
+class Scale(Transform3d):
+    """Transform3d initialized with a scale."""
+    def __init__(self, x=1.0, y=None, z=None, dtype=torch.float32, device="cpu"):
+        super().__init__(dtype=dtype, device=device)
+        if isinstance(x, torch.Tensor):
+            s = x.to(device=device, dtype=dtype)
+            if s.dim() == 0:
+                s = s.expand(3).unsqueeze(0)
+            elif s.dim() == 1 and s.shape[0] == 3:
+                s = s.unsqueeze(0)
+            elif s.dim() == 1 and s.shape[0] == 1:
+                s = s.expand(3).unsqueeze(0)
+        else:
+            if y is None: y = x
+            if z is None: z = x
+            s = torch.tensor([[x, y, z]], dtype=dtype, device=device)
+        S = torch.eye(4, dtype=dtype, device=device).unsqueeze(0).expand(s.shape[0], -1, -1).clone()
+        S[:, 0, 0] = s[:, 0]; S[:, 1, 1] = s[:, 1]; S[:, 2, 2] = s[:, 2]
+        self._matrix = S
+        self.device = self._matrix.device

pytorch3d_stub/pytorch3d/vis/__init__.py

@@ -1 +1,17 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Fvis%2F__init__.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Fvis%2F__init__.py=&etag=%22c887a2b86e91aa7227f07cf6d66d964ee465d552%22
+"""pytorch3d.vis stub."""
+import importlib
+import warnings
+
+def __getattr__(name):
+    if name.startswith("__") and name.endswith("__"):
+        raise AttributeError(name)
+    try:
+        return importlib.import_module(f".{name}", __name__)
+    except ImportError:
+        pass
+    warnings.warn(f"pytorch3d.vis stub: {name} not implemented", stacklevel=2)
+    class _Dummy:
+        def __init__(self, *a, **kw): pass
+        def __call__(self, *a, **kw): return None
+    _Dummy.__name__ = _Dummy.__qualname__ = name
+    return _Dummy

pytorch3d_stub/pytorch3d/vis/plotly_vis.py

@@ -1 +1,42 @@
-Temporary Redirect. Redirecting to /api/resolve-cache/spaces/jboth/sam3d-objects-fixed/7b8ab13b284b67e82dd8c321d957c0080dd66a51/pytorch3d_stub%2Fpytorch3d%2Fvis%2Fplotly_vis.py?%2Fspaces%2Fjboth%2Fsam3d-objects-fixed%2Fresolve%2Fmain%2Fpytorch3d_stub%2Fpytorch3d%2Fvis%2Fplotly_vis.py=&etag=%22623e37cd1073af06175464439f26d85ed2b79241%22
+"""pytorch3d.vis.plotly_vis stub with catch-all."""
+import warnings
+from collections import namedtuple
+
+def __getattr__(name):
+    if name.startswith("__") and name.endswith("__"):
+        raise AttributeError(name)
+    # Return a callable dummy for any missing name
+    def _dummy(*a, **kw): return None
+    _dummy.__name__ = name
+    return _dummy
+
+def plot_scene(plots, **kwargs):
+    return None
+
+def get_camera_wireframe(**kwargs):
+    return None
+
+# These need to be namedtuples with _asdict() support because plot_scene.py calls ._asdict()
+AxisArgs = namedtuple("AxisArgs", ["showgrid", "backgroundcolor", "showticklabels", "tickcolor", "gridcolor", "zeroline"],
+                      defaults=[True, "rgb(230,230,230)", True, "black", "rgb(200,200,200)", False])
+Lighting = namedtuple("Lighting", ["ambient", "diffuse", "specular", "roughness", "fresnel"],
+                      defaults=[0.5, 1.0, 0.3, 0.5, 0.2])
+
+# Explicitly define all private functions that plot_scene imports
+def _add_camera_trace(fig, cameras, trace_name, subplot_idx, ncols, camera_scale, **kw):
+    pass
+
+def _add_pointcloud_trace(fig, pointclouds, trace_name, subplot_idx, ncols, max_points=20000, marker_size=1, **kw):
+    pass
+
+def _add_ray_bundle_trace(fig, ray_bundle, trace_name, subplot_idx, ncols, *a, **kw):
+    pass
+
+def _is_ray_bundle(obj):
+    return False
+
+def _scale_camera_to_bounds(value, vrange, is_position):
+    return value
+
+def _update_axes_bounds(verts_center, max_expand, current_layout):
+    pass