torchrir 0.1.2__tar.gz → 0.1.4__tar.gz

torchrir-0.1.4/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: torchrir
+Version: 0.1.4
+Summary: PyTorch-based room impulse response (RIR) simulation toolkit for static and dynamic scenes.
+Project-URL: Repository, https://github.com/taishi-n/torchrir
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: torch>=2.10.0
+Dynamic: license-file
+
+# TorchRIR
+
+PyTorch-based room impulse response (RIR) simulation toolkit focused on a clean, modern API with GPU support.
+This project has been substantially assisted by AI using Codex.
+
+## Installation
+```bash
+pip install torchrir
+```
+
+## Examples
+- `examples/static.py`: fixed sources/mics with binaural output.  
+  `uv run python examples/static.py --plot`
+- `examples/dynamic_src.py`: moving sources, fixed mics.  
+  `uv run python examples/dynamic_src.py --plot`
+- `examples/dynamic_mic.py`: fixed sources, moving mics.  
+  `uv run python examples/dynamic_mic.py --plot`
+- `examples/cli.py`: unified CLI for static/dynamic scenes, JSON/YAML configs.  
+  `uv run python examples/cli.py --mode static --plot`
+- `examples/cmu_arctic_dynamic_dataset.py`: small dynamic dataset generator (fixed room/mics, randomized source motion).  
+  `uv run python examples/cmu_arctic_dynamic_dataset.py --num-scenes 4 --num-sources 2`
+- `examples/benchmark_device.py`: CPU/GPU benchmark for RIR simulation.  
+  `uv run python examples/benchmark_device.py --dynamic`
+
+## Core API Overview
+- Geometry: `Room`, `Source`, `MicrophoneArray`
+- Static RIR: `simulate_rir`
+- Dynamic RIR: `simulate_dynamic_rir`
+- Dynamic convolution: `DynamicConvolver`
+- Metadata export: `build_metadata`, `save_metadata_json`
+
+```python
+from torchrir import DynamicConvolver, MicrophoneArray, Room, Source, simulate_rir
+
+room = Room.shoebox(size=[6.0, 4.0, 3.0], fs=16000, beta=[0.9] * 6)
+sources = Source.from_positions([[1.0, 2.0, 1.5]])
+mics = MicrophoneArray.from_positions([[2.0, 2.0, 1.5]])
+
+rir = simulate_rir(room=room, sources=sources, mics=mics, max_order=6, tmax=0.3)
+# For dynamic scenes, compute rirs with simulate_dynamic_rir and convolve:
+# y = DynamicConvolver(mode="trajectory").convolve(signal, rirs)
+```
+
+For detailed documentation, see the docs under `docs/` and Read the Docs.
+
+## Future Work
+- Ray tracing backend: implement `RayTracingSimulator` with frequency-dependent absorption/scattering.
+- CUDA-native acceleration: introduce dedicated CUDA kernels for large-scale RIR generation.
+- Dataset expansion: add additional dataset integrations beyond CMU ARCTIC (see `TemplateDataset`).
+- Add regression tests comparing generated RIRs against gpuRIR outputs.
+
+## Related Libraries
+- [gpuRIR](https://github.com/DavidDiazGuerra/gpuRIR)
+- [Cross3D](https://github.com/DavidDiazGuerra/Cross3D)
+- [pyroomacoustics](https://github.com/LCAV/pyroomacoustics)
+- [das-generator](https://github.com/ehabets/das-generator)
+- [rir-generator](https://github.com/audiolabs/rir-generator)

torchrir-0.1.4/README.md

@@ -0,0 +1,57 @@
+# TorchRIR
+
+PyTorch-based room impulse response (RIR) simulation toolkit focused on a clean, modern API with GPU support.
+This project has been substantially assisted by AI using Codex.
+
+## Installation
+```bash
+pip install torchrir
+```
+
+## Examples
+- `examples/static.py`: fixed sources/mics with binaural output.  
+  `uv run python examples/static.py --plot`
+- `examples/dynamic_src.py`: moving sources, fixed mics.  
+  `uv run python examples/dynamic_src.py --plot`
+- `examples/dynamic_mic.py`: fixed sources, moving mics.  
+  `uv run python examples/dynamic_mic.py --plot`
+- `examples/cli.py`: unified CLI for static/dynamic scenes, JSON/YAML configs.  
+  `uv run python examples/cli.py --mode static --plot`
+- `examples/cmu_arctic_dynamic_dataset.py`: small dynamic dataset generator (fixed room/mics, randomized source motion).  
+  `uv run python examples/cmu_arctic_dynamic_dataset.py --num-scenes 4 --num-sources 2`
+- `examples/benchmark_device.py`: CPU/GPU benchmark for RIR simulation.  
+  `uv run python examples/benchmark_device.py --dynamic`
+
+## Core API Overview
+- Geometry: `Room`, `Source`, `MicrophoneArray`
+- Static RIR: `simulate_rir`
+- Dynamic RIR: `simulate_dynamic_rir`
+- Dynamic convolution: `DynamicConvolver`
+- Metadata export: `build_metadata`, `save_metadata_json`
+
+```python
+from torchrir import DynamicConvolver, MicrophoneArray, Room, Source, simulate_rir
+
+room = Room.shoebox(size=[6.0, 4.0, 3.0], fs=16000, beta=[0.9] * 6)
+sources = Source.from_positions([[1.0, 2.0, 1.5]])
+mics = MicrophoneArray.from_positions([[2.0, 2.0, 1.5]])
+
+rir = simulate_rir(room=room, sources=sources, mics=mics, max_order=6, tmax=0.3)
+# For dynamic scenes, compute rirs with simulate_dynamic_rir and convolve:
+# y = DynamicConvolver(mode="trajectory").convolve(signal, rirs)
+```
+
+For detailed documentation, see the docs under `docs/` and Read the Docs.
+
+## Future Work
+- Ray tracing backend: implement `RayTracingSimulator` with frequency-dependent absorption/scattering.
+- CUDA-native acceleration: introduce dedicated CUDA kernels for large-scale RIR generation.
+- Dataset expansion: add additional dataset integrations beyond CMU ARCTIC (see `TemplateDataset`).
+- Add regression tests comparing generated RIRs against gpuRIR outputs.
+
+## Related Libraries
+- [gpuRIR](https://github.com/DavidDiazGuerra/gpuRIR)
+- [Cross3D](https://github.com/DavidDiazGuerra/Cross3D)
+- [pyroomacoustics](https://github.com/LCAV/pyroomacoustics)
+- [das-generator](https://github.com/ehabets/das-generator)
+- [rir-generator](https://github.com/audiolabs/rir-generator)

{torchrir-0.1.2 → torchrir-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "torchrir"
-version = "0.1.2"
+version = "0.1.4"
 description = "PyTorch-based room impulse response (RIR) simulation toolkit for static and dynamic scenes."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -14,8 +14,10 @@ Repository = "https://github.com/taishi-n/torchrir"
 
 [dependency-groups]
 dev = [
+    "commitizen>=3.29.0",
     "git-cliff>=2.10.1",
     "matplotlib>=3.10.8",
+    "ruff>=0.12.2",
     "pillow>=11.2.1",
     "pyroomacoustics>=0.9.0",
     "pytest>=9.0.2",
@@ -23,4 +25,13 @@ dev = [
     "sphinx>=7.0,<8.2.3",
     "sphinx-rtd-theme>=2.0.0",
     "myst-parser>=2.0,<4.0",
+    "ty>=0.0.14,<0.1",
 ]
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+tag_format = "v$version"
+version_scheme = "pep440"
+version_provider = "pep621"
+update_changelog_on_bump = true
+changelog_file = "CHANGELOG.md"

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/__init__.py

@@ -26,7 +26,12 @@ from .datasets import (
     load_wav_mono,
     save_wav,
 )
-from .scene_utils import binaural_mic_positions, clamp_positions, linear_trajectory, sample_positions
+from .scene_utils import (
+    binaural_mic_positions,
+    clamp_positions,
+    linear_trajectory,
+    sample_positions,
+)
 from .utils import (
     att2t_SabineEstimation,
     att2t_sabine_estimation,

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/animation.py

@@ -104,15 +104,15 @@ def animate_scene_gif(
     mic_lines = []
     for _ in range(view_src_traj.shape[1]):
         if view_dim == 2:
-            line, = ax.plot([], [], color="tab:green", alpha=0.6)
+            (line,) = ax.plot([], [], color="tab:green", alpha=0.6)
         else:
-            line, = ax.plot([], [], [], color="tab:green", alpha=0.6)
+            (line,) = ax.plot([], [], [], color="tab:green", alpha=0.6)
         src_lines.append(line)
     for _ in range(view_mic_traj.shape[1]):
         if view_dim == 2:
-            line, = ax.plot([], [], color="tab:orange", alpha=0.6)
+            (line,) = ax.plot([], [], color="tab:orange", alpha=0.6)
         else:
-            line, = ax.plot([], [], [], color="tab:orange", alpha=0.6)
+            (line,) = ax.plot([], [], [], color="tab:orange", alpha=0.6)
         mic_lines.append(line)
 
     ax.legend(loc="best")
@@ -137,15 +137,15 @@ def animate_scene_gif(
                 xy = mic_frame[:, m_idx, :]
                 line.set_data(xy[:, 0], xy[:, 1])
         else:
-            src_scatter._offsets3d = (
-                src_pos_frame[:, 0],
-                src_pos_frame[:, 1],
-                src_pos_frame[:, 2],
+            setattr(
+                src_scatter,
+                "_offsets3d",
+                (src_pos_frame[:, 0], src_pos_frame[:, 1], src_pos_frame[:, 2]),
             )
-            mic_scatter._offsets3d = (
-                mic_pos_frame[:, 0],
-                mic_pos_frame[:, 1],
-                mic_pos_frame[:, 2],
+            setattr(
+                mic_scatter,
+                "_offsets3d",
+                (mic_pos_frame[:, 0], mic_pos_frame[:, 1], mic_pos_frame[:, 2]),
             )
             for s_idx, line in enumerate(src_lines):
                 xyz = src_frame[:, s_idx, :]
@@ -166,7 +166,10 @@ def animate_scene_gif(
             fps = frames / duration_s
         else:
             fps = 6.0
-    anim = animation.FuncAnimation(fig, _frame, frames=frames, interval=1000 / fps, blit=False)
-    anim.save(out_path, writer="pillow", fps=fps)
+    anim = animation.FuncAnimation(
+        fig, _frame, frames=frames, interval=1000 / fps, blit=False
+    )
+    fps_int = None if fps is None else max(1, int(round(fps)))
+    anim.save(out_path, writer="pillow", fps=fps_int)
     plt.close(fig)
     return out_path

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/core.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 """Core RIR simulation functions (static and dynamic)."""
 
 import math
+from collections.abc import Callable
 from typing import Optional, Tuple
 
 import torch
@@ -61,8 +62,8 @@ def simulate_rir(
 
     Example:
         >>> room = Room.shoebox(size=[6.0, 4.0, 3.0], fs=16000, beta=[0.9] * 6)
-        >>> sources = Source.positions([[1.0, 2.0, 1.5]])
-        >>> mics = MicrophoneArray.positions([[2.0, 2.0, 1.5]])
+        >>> sources = Source.from_positions([[1.0, 2.0, 1.5]])
+        >>> mics = MicrophoneArray.from_positions([[2.0, 2.0, 1.5]])
         >>> rir = simulate_rir(
         ...     room=room,
         ...     sources=sources,
@@ -90,9 +91,9 @@ def simulate_rir(
 
     if not isinstance(room, Room):
         raise TypeError("room must be a Room instance")
-    if nsample is None and tmax is None:
-        raise ValueError("nsample or tmax must be provided")
     if nsample is None:
+        if tmax is None:
+            raise ValueError("nsample or tmax must be provided")
         nsample = int(math.ceil(tmax * room.fs))
     if nsample <= 0:
         raise ValueError("nsample must be positive")
@@ -495,7 +496,11 @@ def _compute_image_contributions_batch(
     if mic_pattern != "omni":
         if mic_dir is None:
             raise ValueError("mic orientation required for non-omni directivity")
-        mic_dir = mic_dir[None, :, None, :] if mic_dir.ndim == 2 else mic_dir.view(1, 1, 1, -1)
+        mic_dir = (
+            mic_dir[None, :, None, :]
+            if mic_dir.ndim == 2
+            else mic_dir.view(1, 1, 1, -1)
+        )
         cos_theta = _cos_between(-vec, mic_dir)
         gain = gain * directivity_gain(mic_pattern, cos_theta)
 
@@ -542,9 +547,9 @@ def _accumulate_rir(
     if use_lut:
         sinc_lut = _get_sinc_lut(fdl, lut_gran, device=rir.device, dtype=dtype)
 
-    mic_offsets = (torch.arange(n_mic, device=rir.device, dtype=torch.int64) * nsample).view(
-        n_mic, 1, 1
-    )
+    mic_offsets = (
+        torch.arange(n_mic, device=rir.device, dtype=torch.int64) * nsample
+    ).view(n_mic, 1, 1)
     rir_flat = rir.view(-1)
 
     chunk_size = cfg.accumulate_chunk_size
@@ -559,7 +564,9 @@ def _accumulate_rir(
             x_off_frac = (1.0 - frac_m) * lut_gran
             lut_gran_off = torch.floor(x_off_frac).to(torch.int64)
             x_off = x_off_frac - lut_gran_off.to(dtype)
-            lut_pos = lut_gran_off[..., None] + (n[None, None, :].to(torch.int64) * lut_gran)
+            lut_pos = lut_gran_off[..., None] + (
+                n[None, None, :].to(torch.int64) * lut_gran
+            )
 
             s0 = torch.take(sinc_lut, lut_pos)
             s1 = torch.take(sinc_lut, lut_pos + 1)
@@ -618,9 +625,9 @@ def _accumulate_rir_batch_impl(
     if use_lut:
         sinc_lut = _get_sinc_lut(fdl, lut_gran, device=rir.device, dtype=sample.dtype)
 
-    sm_offsets = (torch.arange(n_sm, device=rir.device, dtype=torch.int64) * nsample).view(
-        n_sm, 1, 1
-    )
+    sm_offsets = (
+        torch.arange(n_sm, device=rir.device, dtype=torch.int64) * nsample
+    ).view(n_sm, 1, 1)
     rir_flat = rir.view(-1)
 
     n_img = idx0.shape[1]
@@ -634,7 +641,9 @@ def _accumulate_rir_batch_impl(
             x_off_frac = (1.0 - frac_m) * lut_gran
             lut_gran_off = torch.floor(x_off_frac).to(torch.int64)
             x_off = x_off_frac - lut_gran_off.to(sample.dtype)
-            lut_pos = lut_gran_off[..., None] + (n[None, None, :].to(torch.int64) * lut_gran)
+            lut_pos = lut_gran_off[..., None] + (
+                n[None, None, :].to(torch.int64) * lut_gran
+            )
 
             s0 = torch.take(sinc_lut, lut_pos)
             s1 = torch.take(sinc_lut, lut_pos + 1)
@@ -660,12 +669,13 @@ _SINC_LUT_CACHE: dict[tuple[int, int, str, torch.dtype], Tensor] = {}
 _FDL_GRID_CACHE: dict[tuple[int, str, torch.dtype], Tensor] = {}
 _FDL_OFFSETS_CACHE: dict[tuple[int, str], Tensor] = {}
 _FDL_WINDOW_CACHE: dict[tuple[int, str, torch.dtype], Tensor] = {}
-_ACCUM_BATCH_COMPILED: dict[tuple[str, torch.dtype, int, int, bool, int], callable] = {}
+_AccumFn = Callable[[Tensor, Tensor, Tensor], None]
+_ACCUM_BATCH_COMPILED: dict[tuple[str, torch.dtype, int, int, bool, int], _AccumFn] = {}
 
 
 def _get_accumulate_fn(
     cfg: SimulationConfig, device: torch.device, dtype: torch.dtype
-) -> callable:
+) -> _AccumFn:
     """Return an accumulation function with config-bound constants."""
     use_lut = cfg.use_lut and device.type != "mps"
     fdl = cfg.frac_delay_length
@@ -721,7 +731,9 @@ def _get_fdl_window(fdl: int, *, device: torch.device, dtype: torch.dtype) -> Te
     return cached
 
 
-def _get_sinc_lut(fdl: int, lut_gran: int, *, device: torch.device, dtype: torch.dtype) -> Tensor:
+def _get_sinc_lut(
+    fdl: int, lut_gran: int, *, device: torch.device, dtype: torch.dtype
+) -> Tensor:
     """Create a sinc lookup table for fractional delays."""
     key = (fdl, lut_gran, str(device), dtype)
     cached = _SINC_LUT_CACHE.get(key)
@@ -765,7 +777,12 @@ def _apply_diffuse_tail(
 
     gen = torch.Generator(device=rir.device)
     gen.manual_seed(0 if seed is None else seed)
-    noise = torch.randn(rir[..., tdiff_idx:].shape, device=rir.device, dtype=rir.dtype, generator=gen)
-    scale = torch.linalg.norm(rir[..., tdiff_idx - 1 : tdiff_idx], dim=-1, keepdim=True) + 1e-8
+    noise = torch.randn(
+        rir[..., tdiff_idx:].shape, device=rir.device, dtype=rir.dtype, generator=gen
+    )
+    scale = (
+        torch.linalg.norm(rir[..., tdiff_idx - 1 : tdiff_idx], dim=-1, keepdim=True)
+        + 1e-8
+    )
     rir[..., tdiff_idx:] = noise * decay * scale
     return rir

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/datasets/cmu_arctic.py

@@ -44,6 +44,7 @@ def list_cmu_arctic_speakers() -> List[str]:
 @dataclass
 class CmuArcticSentence:
     """Sentence metadata from CMU ARCTIC."""
+
     utterance_id: str
     text: str
 
@@ -56,7 +57,9 @@ class CmuArcticDataset:
         >>> audio, fs = dataset.load_wav("arctic_a0001")
     """
 
-    def __init__(self, root: Path, speaker: str = "bdl", download: bool = False) -> None:
+    def __init__(
+        self, root: Path, speaker: str = "bdl", download: bool = False
+    ) -> None:
         """Initialize a CMU ARCTIC dataset handle.
 
         Args:

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/datasets/template.py

@@ -34,7 +34,9 @@ class TemplateDataset(BaseDataset):
         protocol intact.
     """
 
-    def __init__(self, root: Path, speaker: str = "default", download: bool = False) -> None:
+    def __init__(
+        self, root: Path, speaker: str = "default", download: bool = False
+    ) -> None:
         self.root = Path(root)
         self.speaker = speaker
         if download:

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/datasets/utils.py

@@ -10,7 +10,9 @@ import torch
 from .base import BaseDataset, SentenceLike
 
 
-def choose_speakers(dataset: BaseDataset, num_sources: int, rng: random.Random) -> List[str]:
+def choose_speakers(
+    dataset: BaseDataset, num_sources: int, rng: random.Random
+) -> List[str]:
     """Select unique speakers for the requested number of sources.
 
     Example:
@@ -89,4 +91,6 @@ def load_dataset_sources(
         info.append((speaker, utterance_ids))
 
     stacked = torch.stack(signals, dim=0)
+    if fs is None:
+        raise RuntimeError("no audio loaded from dataset sources")
     return stacked, int(fs), info

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/dynamic.py

@@ -44,7 +44,9 @@ class DynamicConvolver:
             if self.hop is None:
                 raise ValueError("hop must be provided for hop mode")
             return _convolve_dynamic_hop(signal, rirs, self.hop)
-        return _convolve_dynamic_trajectory(signal, rirs, timestamps=self.timestamps, fs=self.fs)
+        return _convolve_dynamic_trajectory(
+            signal, rirs, timestamps=self.timestamps, fs=self.fs
+        )
 
 
 def _convolve_dynamic_hop(signal: Tensor, rirs: Tensor, hop: int) -> Tensor:

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/plotting.py

@@ -92,7 +92,9 @@ def plot_scene_dynamic(
     return ax
 
 
-def _setup_axes(ax: Any | None, room: Room | Sequence[float] | Tensor) -> tuple[Any, Any]:
+def _setup_axes(
+    ax: Any | None, room: Room | Sequence[float] | Tensor
+) -> tuple[Any, Any]:
     """Create 2D/3D axes based on room dimension."""
     import matplotlib.pyplot as plt
 
@@ -131,8 +133,9 @@ def _draw_room_2d(ax: Any, size: Tensor) -> None:
     """Draw a 2D rectangular room."""
     import matplotlib.patches as patches
 
-    rect = patches.Rectangle((0.0, 0.0), size[0].item(), size[1].item(),
-                             fill=False, edgecolor="black")
+    rect = patches.Rectangle(
+        (0.0, 0.0), size[0].item(), size[1].item(), fill=False, edgecolor="black"
+    )
     ax.add_patch(rect)
     ax.set_xlim(0, size[0].item())
     ax.set_ylim(0, size[1].item())
@@ -186,7 +189,9 @@ def _draw_room_3d(ax: Any, size: Tensor) -> None:
     ax.set_zlabel("z")
 
 
-def _extract_positions(entity: Source | MicrophoneArray | Tensor | Sequence, ax: Any | None) -> Tensor:
+def _extract_positions(
+    entity: Source | MicrophoneArray | Tensor | Sequence, ax: Any | None
+) -> Tensor:
     """Extract positions from Source/MicrophoneArray or raw tensor."""
     if isinstance(entity, (Source, MicrophoneArray)):
         pos = entity.positions
@@ -211,7 +216,9 @@ def _scatter_positions(
         return
     dim = positions.shape[1]
     if dim == 2:
-        ax.scatter(positions[:, 0], positions[:, 1], label=label, marker=marker, color=color)
+        ax.scatter(
+            positions[:, 0], positions[:, 1], label=label, marker=marker, color=color
+        )
     else:
         ax.scatter(
             positions[:, 0],
@@ -300,4 +307,4 @@ def _is_moving(traj: Tensor, positions: Tensor, *, tol: float = 1e-6) -> bool:
     if traj.numel() == 0:
         return False
     pos0 = positions.unsqueeze(0).expand_as(traj)
-    return torch.any(torch.linalg.norm(traj - pos0, dim=-1) > tol).item()
+    return bool(torch.any(torch.linalg.norm(traj - pos0, dim=-1) > tol).item())

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/plotting_utils.py

@@ -127,7 +127,10 @@ def _positions_to_cpu(entity: torch.Tensor | object) -> torch.Tensor:
     return pos
 
 
-def _traj_steps(src_traj: Optional[torch.Tensor | Sequence], mic_traj: Optional[torch.Tensor | Sequence]) -> int:
+def _traj_steps(
+    src_traj: Optional[torch.Tensor | Sequence],
+    mic_traj: Optional[torch.Tensor | Sequence],
+) -> int:
     """Infer the number of trajectory steps."""
     if src_traj is not None:
         return int(_to_cpu(src_traj).shape[0])

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/room.py

@@ -65,7 +65,7 @@ class Source:
     """Source container with positions and optional orientation.
 
     Example:
-        >>> sources = Source.positions([[1.0, 2.0, 1.5]])
+        >>> sources = Source.from_positions([[1.0, 2.0, 1.5]])
     """
 
     positions: Tensor
@@ -82,24 +82,6 @@ class Source:
         """Return a new Source with updated fields."""
         return replace(self, **kwargs)
 
-    @classmethod
-    def positions(
-        cls,
-        positions: Sequence[Sequence[float]] | Tensor,
-        *,
-        orientation: Optional[Sequence[float] | Tensor] = None,
-        device: Optional[torch.device | str] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> "Source":
-        """Construct a Source from positions.
-
-        Example:
-            >>> sources = Source.positions([[1.0, 2.0, 1.5]])
-        """
-        return cls.from_positions(
-            positions, orientation=orientation, device=device, dtype=dtype
-        )
-
     @classmethod
     def from_positions(
         cls,
@@ -122,7 +104,7 @@ class MicrophoneArray:
     """Microphone array container.
 
     Example:
-        >>> mics = MicrophoneArray.positions([[2.0, 2.0, 1.5]])
+        >>> mics = MicrophoneArray.from_positions([[2.0, 2.0, 1.5]])
     """
 
     positions: Tensor
@@ -139,24 +121,6 @@ class MicrophoneArray:
         """Return a new MicrophoneArray with updated fields."""
         return replace(self, **kwargs)
 
-    @classmethod
-    def positions(
-        cls,
-        positions: Sequence[Sequence[float]] | Tensor,
-        *,
-        orientation: Optional[Sequence[float] | Tensor] = None,
-        device: Optional[torch.device | str] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> "MicrophoneArray":
-        """Construct a MicrophoneArray from positions.
-
-        Example:
-            >>> mics = MicrophoneArray.positions([[2.0, 2.0, 1.5]])
-        """
-        return cls.from_positions(
-            positions, orientation=orientation, device=device, dtype=dtype
-        )
-
     @classmethod
     def from_positions(
         cls,

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/scene_utils.py

@@ -32,7 +32,9 @@ def sample_positions(
     return torch.tensor(coords, dtype=torch.float32)
 
 
-def linear_trajectory(start: torch.Tensor, end: torch.Tensor, steps: int) -> torch.Tensor:
+def linear_trajectory(
+    start: torch.Tensor, end: torch.Tensor, steps: int
+) -> torch.Tensor:
     """Create a linear trajectory between start and end.
 
     Example:
@@ -58,7 +60,9 @@ def binaural_mic_positions(center: torch.Tensor, offset: float = 0.08) -> torch.
     return torch.stack([left, right], dim=0)
 
 
-def clamp_positions(positions: torch.Tensor, room_size: torch.Tensor, margin: float = 0.1) -> torch.Tensor:
+def clamp_positions(
+    positions: torch.Tensor, room_size: torch.Tensor, margin: float = 0.1
+) -> torch.Tensor:
     """Clamp positions to remain inside the room with a margin.
 
     Example:

{torchrir-0.1.2 → torchrir-0.1.4}/src/torchrir/signal.py

@@ -117,9 +117,9 @@ def _convolve_dynamic_rir_trajectory(
     else:
         step_fs = n_samples / t_steps
         ts_dtype = torch.float32 if signal.device.type == "mps" else torch.float64
-        w_ini = (torch.arange(t_steps, device=signal.device, dtype=ts_dtype) * step_fs).to(
-            torch.long
-        )
+        w_ini = (
+            torch.arange(t_steps, device=signal.device, dtype=ts_dtype) * step_fs
+        ).to(torch.long)
 
     w_ini = torch.cat(
         [w_ini, torch.tensor([n_samples], device=signal.device, dtype=torch.long)]
@@ -132,14 +132,18 @@ def _convolve_dynamic_rir_trajectory(
         )
 
     max_len = int(w_len.max().item())
-    segments = torch.zeros((t_steps, n_src, max_len), dtype=signal.dtype, device=signal.device)
+    segments = torch.zeros(
+        (t_steps, n_src, max_len), dtype=signal.dtype, device=signal.device
+    )
     for t in range(t_steps):
         start = int(w_ini[t].item())
         end = int(w_ini[t + 1].item())
         if end > start:
             segments[t, :, : end - start] = signal[:, start:end]
 
-    out = torch.zeros((n_mic, n_samples + rir_len - 1), dtype=signal.dtype, device=signal.device)
+    out = torch.zeros(
+        (n_mic, n_samples + rir_len - 1), dtype=signal.dtype, device=signal.device
+    )
 
     for t in range(t_steps):
         seg_len = int(w_len[t].item())
@@ -166,7 +170,9 @@ def _convolve_dynamic_rir_trajectory_batched(
     """GPU-friendly batched trajectory convolution using FFT."""
     n_samples = signal.shape[1]
     t_steps, n_src, n_mic, rir_len = rirs.shape
-    out = torch.zeros((n_mic, n_samples + rir_len - 1), dtype=signal.dtype, device=signal.device)
+    out = torch.zeros(
+        (n_mic, n_samples + rir_len - 1), dtype=signal.dtype, device=signal.device
+    )
 
     for t0 in range(0, t_steps, chunk_size):
         t1 = min(t0 + chunk_size, t_steps)
@@ -174,7 +180,9 @@ def _convolve_dynamic_rir_trajectory_batched(
         max_len = int(lengths.max().item())
         if max_len == 0:
             continue
-        segments = torch.zeros((t1 - t0, n_src, max_len), dtype=signal.dtype, device=signal.device)
+        segments = torch.zeros(
+            (t1 - t0, n_src, max_len), dtype=signal.dtype, device=signal.device
+        )
         for idx, t in enumerate(range(t0, t1)):
             start = int(w_ini[t].item())
             end = int(w_ini[t + 1].item())
@@ -190,7 +198,9 @@ def _convolve_dynamic_rir_trajectory_batched(
             dtype=signal.dtype,
             device=signal.device,
         )
-        conv = torch.fft.irfft(seg_f[:, :, None, :] * rir_f, n=fft_len, dim=-1, out=conv_out)
+        conv = torch.fft.irfft(
+            seg_f[:, :, None, :] * rir_f, n=fft_len, dim=-1, out=conv_out
+        )
         conv = conv[..., :conv_len]
         conv_sum = conv.sum(dim=1)
 
@@ -199,7 +209,9 @@ def _convolve_dynamic_rir_trajectory_batched(
             if seg_len == 0:
                 continue
             start = int(w_ini[t].item())
-            out[:, start : start + seg_len + rir_len - 1] += conv_sum[idx, :, : seg_len + rir_len - 1]
+            out[:, start : start + seg_len + rir_len - 1] += conv_sum[
+                idx, :, : seg_len + rir_len - 1
+            ]
 
     return out.squeeze(0) if n_mic == 1 else out
 
@@ -221,7 +233,9 @@ def _ensure_static_rirs(rirs: Tensor) -> Tensor:
         return rirs.view(1, rirs.shape[0], rirs.shape[1])
     if rirs.ndim == 3:
         return rirs
-    raise ValueError("rirs must have shape (rir_len,), (n_mic, rir_len), or (n_src, n_mic, rir_len)")
+    raise ValueError(
+        "rirs must have shape (rir_len,), (n_mic, rir_len), or (n_src, n_mic, rir_len)"
+    )
 
 
 def _ensure_dynamic_rirs(rirs: Tensor, signal: Tensor) -> Tensor: