canns 0.12.7__py3-none-any.whl → 0.13.0__py3-none-any.whl

canns/analyzer/data/legacy/__init__.py

@@ -0,0 +1,6 @@
+"""Legacy data-analysis modules (deprecated)."""
+
+__all__ = [
+    "cann1d",
+    "cann2d",
+]

canns/analyzer/data/{cann1d.py → legacy/cann1d.py}

@@ -9,7 +9,7 @@ from scipy.optimize import linear_sum_assignment
 from scipy.special import i0
 from tqdm import tqdm
 
-from ..visualization.core.jupyter_utils import (
+from ...visualization.core.jupyter_utils import (
     display_animation_in_jupyter,
     is_jupyter_environment,
 )
@@ -45,7 +45,7 @@ except ImportError:
 from canns.data.loaders import load_roi_data
 
 # Import PlotConfig for unified plotting
-from ..visualization import PlotConfig
+from ...visualization import PlotConfig
 
 
 # ==================== Configuration Classes ====================

canns/analyzer/data/{cann2d.py → legacy/cann2d.py}

@@ -29,8 +29,8 @@ from sklearn import preprocessing
 from tqdm import tqdm
 
 # Import PlotConfig for unified plotting
-from ..visualization import PlotConfig
-from ..visualization.core.jupyter_utils import (
+from ...visualization import PlotConfig
+from ...visualization.core.jupyter_utils import (
     display_animation_in_jupyter,
     is_jupyter_environment,
 )
@@ -2168,7 +2168,7 @@ def plot_2d_bump_on_manifold(
     """
     import matplotlib.animation as animation
 
-    from ..visualization.core.jupyter_utils import (
+    from ...visualization.core.jupyter_utils import (
         display_animation_in_jupyter,
         is_jupyter_environment,
     )

canns/analyzer/visualization/core/backend.py

@@ -99,7 +99,7 @@ def select_animation_backend(
             return BackendSelection(
                 backend="imageio",
                 supports_parallel=True,
-                reason=f"User explicitly requested imageio backend",
+                reason="User explicitly requested imageio backend",
                 warnings=[],
             )
 

canns/analyzer/visualization/core/config.py

@@ -268,6 +268,83 @@ class PlotConfigs:
         defaults.update(kwargs)
         return PlotConfig.for_animation(time_steps, **defaults)
 
+    @staticmethod
+    def cohomap(**kwargs: Any) -> PlotConfig:
+        defaults: dict[str, Any] = {
+            "title": "CohoMap",
+            "xlabel": "",
+            "ylabel": "",
+            "figsize": (10, 4),
+        }
+        defaults.update(kwargs)
+        return PlotConfig.for_static_plot(**defaults)
+
+    @staticmethod
+    def cohospace_trajectory(**kwargs: Any) -> PlotConfig:
+        defaults: dict[str, Any] = {
+            "title": "CohoSpace trajectory",
+            "xlabel": "theta1 (deg)",
+            "ylabel": "theta2 (deg)",
+            "figsize": (6, 6),
+        }
+        defaults.update(kwargs)
+        return PlotConfig.for_static_plot(**defaults)
+
+    @staticmethod
+    def cohospace_neuron(**kwargs: Any) -> PlotConfig:
+        defaults: dict[str, Any] = {
+            "title": "Neuron activity on coho-space",
+            "xlabel": "Theta 1 (deg)",
+            "ylabel": "Theta 2 (deg)",
+            "figsize": (6, 6),
+        }
+        defaults.update(kwargs)
+        return PlotConfig.for_static_plot(**defaults)
+
+    @staticmethod
+    def cohospace_population(**kwargs: Any) -> PlotConfig:
+        defaults: dict[str, Any] = {
+            "title": "Population activity on coho-space",
+            "xlabel": "Theta 1 (deg)",
+            "ylabel": "Theta 2 (deg)",
+            "figsize": (6, 6),
+        }
+        defaults.update(kwargs)
+        return PlotConfig.for_static_plot(**defaults)
+
+    @staticmethod
+    def fr_heatmap(**kwargs: Any) -> PlotConfig:
+        defaults: dict[str, Any] = {
+            "title": "Firing Rate Heatmap",
+            "xlabel": "Time",
+            "ylabel": "Neuron",
+            "figsize": (10, 5),
+            "clabel": "Value",
+        }
+        defaults.update(kwargs)
+        return PlotConfig.for_static_plot(**defaults)
+
+    @staticmethod
+    def frm(**kwargs: Any) -> PlotConfig:
+        defaults: dict[str, Any] = {
+            "title": "Firing Rate Map",
+            "xlabel": "X bin",
+            "ylabel": "Y bin",
+            "figsize": (6, 5),
+            "clabel": "Rate",
+        }
+        defaults.update(kwargs)
+        return PlotConfig.for_static_plot(**defaults)
+
+    @staticmethod
+    def path_compare(**kwargs: Any) -> PlotConfig:
+        defaults: dict[str, Any] = {
+            "title": "Path Compare",
+            "figsize": (12, 5),
+        }
+        defaults.update(kwargs)
+        return PlotConfig.for_static_plot(**defaults)
+
     @staticmethod
     def raster_plot(mode: str = "block", **kwargs: Any) -> PlotConfig:
         defaults: dict[str, Any] = {

canns/analyzer/visualization/core/rendering.py

@@ -325,10 +325,9 @@ def render_animation_parallel(
         ... else:
         ...     print("imageio not available")
     """
-    import os
     import multiprocessing as mp
-    import platform
-    from concurrent.futures import ProcessPoolExecutor
+    import os
+
     from tqdm import tqdm
 
     # Detect file format
@@ -487,7 +486,12 @@ def _render_mp4_parallel(
     if IMAGEIO_AVAILABLE:
         # Try imageio first (simpler, more reliable if ffmpeg plugin available)
         try:
-            writer_kwargs = {"fps": fps, "codec": "libx264", "pixelformat": "yuv420p", "bitrate": "5000k"}
+            writer_kwargs = {
+                "fps": fps,
+                "codec": "libx264",
+                "pixelformat": "yuv420p",
+                "bitrate": "5000k",
+            }
             with imageio.get_writer(save_path, **writer_kwargs) as writer:
                 for frame in frames:
                     # Ensure RGB format
@@ -512,14 +516,14 @@ def _render_mp4_parallel(
     h, w = frames[0].shape[:2]
     fig = plt.figure(figsize=(w / 100, h / 100), dpi=100, frameon=False)
     ax = fig.add_axes([0, 0, 1, 1])
-    ax.axis('off')
+    ax.axis("off")
 
     writer = FFMpegWriter(fps=fps, codec="h264", bitrate=5000)
     with writer.saving(fig, save_path, dpi=100):
         for frame in frames:
             ax.clear()
             ax.imshow(frame)
-            ax.axis('off')
+            ax.axis("off")
             writer.grab_frame()
 
     plt.close(fig)

canns/analyzer/visualization/energy_plots.py

@@ -45,9 +45,10 @@ def _render_single_energy_1d_frame(
     options: _Energy1DRenderOptions,
 ) -> np.ndarray:
     """Render a single frame for 1D energy landscape animation (module-level for pickling)."""
+    from io import BytesIO
+
     import matplotlib.pyplot as plt
     import numpy as np
-    from io import BytesIO
 
     fig, ax = plt.subplots(figsize=options.figsize)
     sim_index = options.sim_indices_to_render[frame_index]
@@ -121,9 +122,10 @@ def _render_single_energy_2d_frame(
     options: _Energy2DRenderOptions,
 ) -> np.ndarray:
     """Render a single frame for 2D energy landscape animation (module-level for pickling)."""
+    from io import BytesIO
+
     import matplotlib.pyplot as plt
     import numpy as np
-    from io import BytesIO
 
     fig, ax = plt.subplots(figsize=options.figsize)
     sim_index = options.sim_indices_to_render[frame_index]
@@ -457,8 +459,12 @@ def energy_landscape_1d_animation(
 
             if backend == "imageio":
                 # Use imageio backend with parallel rendering
-                workers = render_workers if render_workers is not None else get_optimal_worker_count()
-                ctx, start_method = get_multiprocessing_context(prefer_fork=(render_start_method == "fork"))
+                workers = (
+                    render_workers if render_workers is not None else get_optimal_worker_count()
+                )
+                ctx, start_method = get_multiprocessing_context(
+                    prefer_fork=(render_start_method == "fork")
+                )
 
                 # Create render options
                 render_options = _Energy1DRenderOptions(
@@ -481,9 +487,10 @@ def energy_landscape_1d_animation(
                 writer_kwargs, mode = get_imageio_writer_kwargs(config.save_path, config.fps)
 
                 try:
-                    import imageio
                     from functools import partial
 
+                    import imageio
+
                     # Create partial function with options
                     render_func = partial(_render_single_energy_1d_frame, options=render_options)
 
@@ -519,6 +526,7 @@ def energy_landscape_1d_animation(
 
                 except Exception as e:
                     import warnings
+
                     warnings.warn(
                         f"imageio rendering failed: {e}. Falling back to matplotlib.",
                         RuntimeWarning,
@@ -853,8 +861,12 @@ def energy_landscape_2d_animation(
 
             if backend == "imageio":
                 # Use imageio backend with parallel rendering
-                workers = render_workers if render_workers is not None else get_optimal_worker_count()
-                ctx, start_method = get_multiprocessing_context(prefer_fork=(render_start_method == "fork"))
+                workers = (
+                    render_workers if render_workers is not None else get_optimal_worker_count()
+                )
+                ctx, start_method = get_multiprocessing_context(
+                    prefer_fork=(render_start_method == "fork")
+                )
 
                 # Create render options
                 render_options = _Energy2DRenderOptions(
@@ -877,9 +889,10 @@ def energy_landscape_2d_animation(
                 writer_kwargs, mode = get_imageio_writer_kwargs(config.save_path, config.fps)
 
                 try:
-                    import imageio
                     from functools import partial
 
+                    import imageio
+
                     # Create partial function with options
                     render_func = partial(_render_single_energy_2d_frame, options=render_options)
 
@@ -915,6 +928,7 @@ def energy_landscape_2d_animation(
 
                 except Exception as e:
                     import warnings
+
                     warnings.warn(
                         f"imageio rendering failed: {e}. Falling back to matplotlib.",
                         RuntimeWarning,

canns/analyzer/visualization/spatial_plots.py

@@ -49,9 +49,10 @@ def _render_single_grid_tracking_frame(
     options: _GridCellTrackingRenderOptions,
 ) -> np.ndarray:
     """Render a single frame for grid cell tracking animation (module-level for pickling)."""
+    from io import BytesIO
+
     import matplotlib.pyplot as plt
     import numpy as np
-    from io import BytesIO
 
     fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=options.figsize)
     sim_idx = options.sim_indices_to_render[frame_index]
@@ -84,12 +85,19 @@ def _render_single_grid_tracking_frame(
 
     # Panel 3: Rate map with position
     im = ax3.imshow(
-        options.rate_map.T, origin="lower", cmap="hot",
-        extent=[0, options.env_size, 0, options.env_size], aspect="auto"
+        options.rate_map.T,
+        origin="lower",
+        cmap="hot",
+        extent=[0, options.env_size, 0, options.env_size],
+        aspect="auto",
     )
     ax3.plot(
-        [options.position[sim_idx, 0]], [options.position[sim_idx, 1]], "c*",
-        markersize=15, markeredgecolor="white", markeredgewidth=1.5
+        [options.position[sim_idx, 0]],
+        [options.position[sim_idx, 1]],
+        "c*",
+        markersize=15,
+        markeredgecolor="white",
+        markeredgewidth=1.5,
     )
     ax3.set_xlabel("X Position (m)", fontsize=10)
     ax3.set_ylabel("Y Position (m)", fontsize=10)
@@ -97,7 +105,9 @@ def _render_single_grid_tracking_frame(
     plt.colorbar(im, ax=ax3, fraction=0.046, pad=0.04)
 
     # Overall title with time
-    fig.suptitle(f"{options.title}  |  Time: {current_time_s:.2f} s", fontsize=13, fontweight="bold")
+    fig.suptitle(
+        f"{options.title}  |  Time: {current_time_s:.2f} s", fontsize=13, fontweight="bold"
+    )
 
     fig.tight_layout()
 
@@ -792,8 +802,12 @@ def create_grid_cell_tracking_animation(
 
             if backend == "imageio":
                 # Use imageio backend with parallel rendering
-                workers = render_workers if render_workers is not None else get_optimal_worker_count()
-                ctx, start_method = get_multiprocessing_context(prefer_fork=(render_start_method == "fork"))
+                workers = (
+                    render_workers if render_workers is not None else get_optimal_worker_count()
+                )
+                ctx, start_method = get_multiprocessing_context(
+                    prefer_fork=(render_start_method == "fork")
+                )
 
                 # Create render options
                 render_options = _GridCellTrackingRenderOptions(
@@ -813,11 +827,14 @@ def create_grid_cell_tracking_animation(
                 writer_kwargs, mode = get_imageio_writer_kwargs(config.save_path, config.fps)
 
                 try:
-                    import imageio
                     from functools import partial
 
+                    import imageio
+
                     # Create partial function with options
-                    render_func = partial(_render_single_grid_tracking_frame, options=render_options)
+                    render_func = partial(
+                        _render_single_grid_tracking_frame, options=render_options
+                    )
 
                     with imageio.get_writer(config.save_path, mode=mode, **writer_kwargs) as writer:
                         if workers > 1 and ctx is not None:
@@ -851,6 +868,7 @@ def create_grid_cell_tracking_animation(
 
                 except Exception as e:
                     import warnings
+
                     warnings.warn(
                         f"imageio rendering failed: {e}. Falling back to matplotlib.",
                         RuntimeWarning,
@@ -880,7 +898,9 @@ def create_grid_cell_tracking_animation(
                         pbar.update(1)
 
                     try:
-                        ani.save(config.save_path, writer=writer, progress_callback=progress_callback)
+                        ani.save(
+                            config.save_path, writer=writer, progress_callback=progress_callback
+                        )
                         print(f"Animation saved to: {config.save_path}")
                     finally:
                         pbar.close()

canns/analyzer/visualization/theta_sweep_plots.py

@@ -25,7 +25,6 @@ from tqdm import tqdm
 
 from .core.backend import (
     emit_backend_warnings,
-    get_imageio_writer_kwargs,
     get_multiprocessing_context,
     get_optimal_worker_count,
     select_animation_backend,
@@ -851,9 +850,10 @@ def _render_single_place_cell_frame(
     options: _PlaceCellRenderOptions,
 ) -> np.ndarray:
     """Render a single frame for place cell animation (module-level for pickling)."""
+    from io import BytesIO
+
     import matplotlib.pyplot as plt
     import numpy as np
-    from io import BytesIO
 
     fig, axes = plt.subplots(1, 2, figsize=options.figsize, width_ratios=[1, 1])
     ax_env, ax_activity = axes
@@ -1223,7 +1223,9 @@ def create_theta_sweep_place_cell_animation(
         if backend == "imageio":
             # Use imageio backend with parallel rendering
             workers = render_workers if render_workers is not None else get_optimal_worker_count()
-            ctx, start_method = get_multiprocessing_context(prefer_fork=(render_start_method == "fork"))
+            ctx, start_method = get_multiprocessing_context(
+                prefer_fork=(render_start_method == "fork")
+            )
 
             _emit_info(
                 f"Parallel rendering enabled: {workers} workers (start_method={start_method})"
@@ -1232,7 +1234,11 @@ def create_theta_sweep_place_cell_animation(
             # Prepare environment data
             env = navigation_task.env
             boundary_array = np.array(env.boundary) if env.boundary is not None else None
-            walls_arrays = [np.array(wall) for wall in env.walls] if env.walls is not None and len(env.walls) > 0 else None
+            walls_arrays = (
+                [np.array(wall) for wall in env.walls]
+                if env.walls is not None and len(env.walls) > 0
+                else None
+            )
 
             # Get accessible indices
             accessible_indices = pc_network.geodesic_result.accessible_indices
@@ -1257,11 +1263,14 @@ def create_theta_sweep_place_cell_animation(
             writer_kwargs, mode = get_imageio_writer_kwargs(config.save_path, config.fps)
 
             try:
-                import imageio
                 from functools import partial
 
+                import imageio
+
                 # Create partial function with data and options
-                render_func = partial(_render_single_place_cell_frame, data=data, options=render_options)
+                render_func = partial(
+                    _render_single_place_cell_frame, data=data, options=render_options
+                )
 
                 with imageio.get_writer(config.save_path, mode=mode, **writer_kwargs) as writer:
                     if workers > 1 and ctx is not None:

canns/pipeline/__init__.py

@@ -7,15 +7,11 @@ the underlying implementations.
 """
 
 from ._base import Pipeline
-from .theta_sweep import (
-    ThetaSweepPipeline,
-    batch_process_trajectories,
-    load_trajectory_from_csv,
-)
+from .asa import ASAApp
+from .asa import main as asa_main
 
 __all__ = [
     "Pipeline",
-    "ThetaSweepPipeline",
-    "load_trajectory_from_csv",
-    "batch_process_trajectories",
+    "ASAApp",
+    "asa_main",
 ]

canns/pipeline/asa/__init__.py

@@ -0,0 +1,21 @@
+"""ASA TUI - Terminal User Interface for ASA Analysis.
+
+This module provides a Textual-based TUI for running ASA (Attractor State Analysis)
+with 7 analysis modules: TDA, CohoMap, PathCompare, CohoSpace, FR, FRM, and GridScore.
+"""
+
+import os
+
+__all__ = ["ASAApp", "main"]
+
+
+def main():
+    """Entry point for canns-tui command."""
+    os.environ.setdefault("MPLBACKEND", "Agg")
+    from .app import ASAApp
+
+    app = ASAApp()
+    app.run()
+
+
+from .app import ASAApp

canns/pipeline/asa/__main__.py

@@ -0,0 +1,11 @@
+"""Main entry point for running ASA TUI as a module."""
+
+import os
+
+os.environ.setdefault("MPLBACKEND", "Agg")
+
+from .app import ASAApp
+
+if __name__ == "__main__":
+    app = ASAApp()
+    app.run()