synaptipy 0.1.1b4__py3-none-any.whl

Synaptipy/__init__.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""
+Synaptipy: A multi-channel electrophysiology visualization and analysis toolkit.
+
+This package provides tools for loading, visualizing, and exporting
+electrophysiology data using the neo library and a Qt-based graphical interface.
+"""
+
+# PEP 396 style version marker
+__version__ = "0.1.1b4"
+__author__ = "Anzal K Shahul"
+__email__ = "anzal.ks@gmail.com"
+__license__ = "AGPL-3.0-or-later"
+
+# Define the primary public API exposed directly by 'import Synaptipy'
+# Usually just metadata for library packages.
+__all__ = ["__version__", "__author__", "__email__", "__license__"]
+
+# Optional: Configure root logger basic settings if not done elsewhere
+# import logging
+# logging.getLogger(__name__).addHandler(logging.NullHandler())

Synaptipy/__main__.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""
+Synaptipy - Multi-channel Electrophysiology Visualization and Analysis Toolkit
+
+This module serves as the entry point for the package when run as:
+    python -m Synaptipy
+
+It parses command line arguments and launches the application with the appropriate settings.
+
+This file is part of Synaptipy, licensed under the GNU Affero General Public License v3.0.
+See the LICENSE file in the root of the repository for full license details.
+"""
+
+import argparse
+import logging
+import os
+import sys
+from pathlib import Path
+
+# Set up logging before importing the rest of the package
+from Synaptipy.shared.logging_config import setup_logging
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Synaptipy - Electrophysiology Visualization and Analysis Toolkit",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--dev", action="store_true", help="Run in development mode with increased logging")
+    parser.add_argument("--log-dir", type=str, default=None, help="Directory to store log files")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Increase output verbosity")
+    parser.add_argument("--version", action="store_true", help="Show version information and exit")
+    parser.add_argument("--file", type=str, default=None, help="Open a specific file on startup")
+
+    return parser.parse_args()
+
+
+def main():
+    """Main entry point for the application."""
+    args = parse_args()
+
+    # Show version and exit if requested
+    if args.version:
+        from Synaptipy import __version__
+
+        print(f"Synaptipy version {__version__}")
+        return 0
+
+    # Set up environment variables based on arguments
+    if args.dev:
+        os.environ["SYNAPTIPY_DEV_MODE"] = "1"
+
+    # Configure logging
+    _log_level = logging.DEBUG if args.verbose or args.dev else logging.INFO  # noqa: F841
+    setup_logging(dev_mode=args.dev, log_dir=args.log_dir)
+    logger = logging.getLogger(__name__)
+
+    logger.info("Starting Synaptipy...")
+    logger.debug(f"Command line arguments: {args}")
+
+    # Import GUI components here to avoid circular imports
+    try:
+        from Synaptipy.application.__main__ import run_gui
+
+        # Launch the GUI
+        initial_file = Path(args.file) if args.file else None
+        if initial_file and not initial_file.exists():
+            logger.error(f"File not found: {initial_file}")
+            print(f"Error: File not found: {initial_file}")
+            return 1
+
+        return run_gui()
+    except ImportError as e:
+        logger.error(f"Failed to import GUI components: {e}")
+        print(f"Error: Failed to import GUI components: {e}")
+        print("Make sure PySide6 is installed properly.")
+        return 1
+    except Exception as e:
+        logger.exception(f"Unexpected error: {e}")
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Synaptipy/application/__init__.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+"""
+Application Layer for Synaptipy.
+
+Contains the user interface (GUI, CLI) and logic that orchestrates
+user interactions with the core domain and infrastructure layers.
+"""
+
+# Nothing essential needs to be exposed directly from here for typical use.
+# Users will typically interact via the main entry point or specific UI/CLI modules.
+__all__ = []

Synaptipy/application/__main__.py

@@ -0,0 +1,251 @@
+# src/Synaptipy/application/__main__.py
+# -*- coding: utf-8 -*-
+"""
+Main entry point for the Synaptipy Viewer GUI application.
+
+This module is responsible for:
+1. Processing command line arguments
+2. Setting up the logging system with dev mode support
+3. Initializing the Qt application and UI styling
+4. Creating and displaying the welcome screen with startup manager
+5. Running the event loop
+
+The module defines the `run_gui` function called by the entry point script
+defined in pyproject.toml.
+
+This file is part of Synaptipy, licensed under the GNU Affero General Public License v3.0.
+See the LICENSE file in the root of the repository for full license details.
+"""
+
+import argparse
+import faulthandler
+import logging
+import os
+import sys
+import traceback
+
+# Suppress annoying pyqtgraph RuntimeWarnings (overflow in cast)
+import warnings
+
+from PySide6 import QtCore, QtGui, QtWidgets
+
+# --- Import Core Components ---
+from Synaptipy.application.startup_manager import StartupManager
+from Synaptipy.shared.logging_config import setup_logging
+
+warnings.filterwarnings("ignore", category=RuntimeWarning, module="pyqtgraph")
+
+# Enable low-level C traceback on SIGBUS/SIGSEGV so fatal crashes include a
+# Python stack trace in the log (zero overhead in normal operation).
+faulthandler.enable()
+
+# Log instance to be initialized after setting up logging
+log = logging.getLogger(__name__)
+
+
+def parse_arguments():
+    """
+    Parse command line arguments for the application.
+
+    Returns:
+        argparse.Namespace: Parsed command line arguments
+    """
+    parser = argparse.ArgumentParser(description="Synaptipy - Electrophysiology Visualization Suite")
+    parser.add_argument("--dev", action="store_true", help="Enable development mode with verbose logging")
+    parser.add_argument("--log-dir", type=str, help="Custom directory for log files")
+    parser.add_argument("--log-file", type=str, help="Custom log filename")
+    return parser.parse_args()
+
+
+# ---------------------------------------------------------------------------
+# Graceful crash reporter
+# ---------------------------------------------------------------------------
+
+
+class CrashReportDialog(QtWidgets.QDialog):
+    """Non-modal dialog shown when an unhandled Python exception escapes to the
+    top level.  Displays the full traceback in a read-only text area and
+    provides a one-click "Copy to Clipboard" button so the user can paste the
+    report directly into a GitHub Issue.
+    """
+
+    _GITHUB_ISSUES_URL = "https://github.com/anzalks/synaptipy/issues/new"
+
+    def __init__(self, traceback_text: str, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Synaptipy — Unexpected Error")
+        self.setMinimumSize(680, 420)
+        self._traceback_text = traceback_text
+        self._build_ui()
+
+    def _build_ui(self) -> None:
+        layout = QtWidgets.QVBoxLayout(self)
+
+        # ---- Header ----
+        header = QtWidgets.QLabel(
+            "<b>An unexpected error occurred.</b><br>"
+            "The error details are shown below. "
+            "Please click <i>Copy to Clipboard</i> and paste them into a "
+            "<a href='{url}'>GitHub Issue</a> so we can fix this.".format(url=self._GITHUB_ISSUES_URL)
+        )
+        header.setWordWrap(True)
+        header.setOpenExternalLinks(True)
+        layout.addWidget(header)
+
+        # ---- Traceback ----
+        self._text_area = QtWidgets.QPlainTextEdit()
+        self._text_area.setReadOnly(True)
+        self._text_area.setPlainText(self._traceback_text)
+        font = QtGui.QFont("Courier New", 9)
+        font.setStyleHint(QtGui.QFont.StyleHint.Monospace)
+        self._text_area.setFont(font)
+        layout.addWidget(self._text_area)
+
+        # ---- Buttons ----
+        btn_box = QtWidgets.QDialogButtonBox()
+        copy_btn = btn_box.addButton("Copy to Clipboard", QtWidgets.QDialogButtonBox.ButtonRole.ActionRole)
+        close_btn = btn_box.addButton(QtWidgets.QDialogButtonBox.StandardButton.Close)
+        copy_btn.clicked.connect(self._copy_to_clipboard)
+        close_btn.clicked.connect(self.accept)
+        layout.addWidget(btn_box)
+
+    def _copy_to_clipboard(self) -> None:
+        QtWidgets.QApplication.clipboard().setText(self._traceback_text)
+
+
+def _install_excepthook() -> None:
+    """Replace ``sys.excepthook`` with a GUI-aware crash reporter.
+
+    When an unhandled exception propagates to the top of the event loop,
+    the default hook prints to stderr and silently exits.  Our replacement
+    logs the traceback, then pops up a ``CrashReportDialog`` so the user
+    can copy the error into a GitHub Issue.
+
+    The hook is intentionally *not* installed for ``SystemExit`` and
+    ``KeyboardInterrupt`` so normal shutdown and Ctrl-C still work.
+    """
+
+    def _excepthook(exc_type, exc_value, exc_tb):
+        if issubclass(exc_type, (SystemExit, KeyboardInterrupt)):
+            sys.__excepthook__(exc_type, exc_value, exc_tb)
+            return
+
+        tb_str = "".join(traceback.format_exception(exc_type, exc_value, exc_tb))
+        log.critical("Unhandled exception:\n%s", tb_str)
+
+        app = QtWidgets.QApplication.instance()
+        if app is not None:
+            try:
+                dlg = CrashReportDialog(tb_str)
+                dlg.exec()
+            except Exception:
+                # If the dialog itself fails, fall back to stderr
+                sys.__excepthook__(exc_type, exc_value, exc_tb)
+        else:
+            sys.__excepthook__(exc_type, exc_value, exc_tb)
+
+    sys.excepthook = _excepthook
+
+
+def run_gui():  # noqa: C901
+    """
+    Set up and run the Synaptipy GUI application with welcome screen.
+
+    This function:
+    1. Parses command line arguments
+    2. Configures the logging system
+    3. Initializes the Qt application
+    4. Creates and displays the welcome screen
+    5. Manages startup process with progress tracking
+    6. Runs the Qt event loop
+
+    Returns:
+        int: The application exit code
+    """
+    # Parse command line arguments
+    args = parse_arguments()
+
+    # Check for dev mode environment variable
+    env_dev_mode = os.environ.get("SYNAPTIPY_DEV_MODE")
+    if env_dev_mode and env_dev_mode.lower() in ("1", "true", "yes"):
+        dev_mode = True
+    else:
+        dev_mode = args.dev
+
+    # Setup logging with the appropriate mode
+    setup_logging(dev_mode=dev_mode, log_dir=args.log_dir, log_filename=args.log_file)
+
+    log.info("Application starting...")
+    if dev_mode:
+        log.info("Running in DEVELOPMENT mode with verbose logging")
+
+    # Create Qt Application with High DPI support
+    app = QtWidgets.QApplication.instance()
+    if app is None:
+        # Enable High DPI scaling before creating QApplication
+        # Check if HighDpiScaleFactorRoundingPolicy is available (Qt 6.0+)
+        if hasattr(QtCore.Qt, "HighDpiScaleFactorRoundingPolicy"):
+            try:
+                QtWidgets.QApplication.setHighDpiScaleFactorRoundingPolicy(
+                    QtCore.Qt.HighDpiScaleFactorRoundingPolicy.PassThrough
+                )
+                log.debug("High DPI PassThrough policy set successfully")
+            except Exception as e:
+                log.warning(f"Could not set High DPI policy: {e}")
+
+        app = QtWidgets.QApplication(sys.argv)
+
+        # Enable High DPI pixmaps (for better icon rendering)
+        try:
+            app.setAttribute(QtCore.Qt.ApplicationAttribute.AA_UseHighDpiPixmaps, True)
+        except Exception as e:
+            log.warning(f"Could not enable High DPI pixmaps: {e}")
+
+    # Force locale to English/US to ensure dot decimal separators
+    # This fixes issues where European locales force comma separators in spinboxes
+    QtCore.QLocale.setDefault(QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates))
+    log.debug("Forced application locale to English/US (dot decimal separator)")
+
+    # Install the GUI-aware crash reporter so unhandled exceptions show a
+    # dialog with a "Copy to Clipboard" button instead of silently exiting.
+    _install_excepthook()
+    log.debug("Crash-report excepthook installed.")
+
+    # Create startup manager and begin loading process
+    try:
+        startup_manager = StartupManager(app)
+        welcome_screen = startup_manager.start_loading()
+
+        # Show welcome screen immediately and force display
+        welcome_screen.show()
+        welcome_screen.raise_()  # Bring to front
+        welcome_screen.activateWindow()  # Activate the window
+
+        # Force Qt to process events and display the window immediately
+        app.processEvents()
+
+        # Use the optimized display method
+        welcome_screen.force_display()
+
+        log.debug("Welcome screen displayed, beginning startup process")
+
+    except Exception as e:
+        log.critical(f"Failed to create startup manager: {e}", exc_info=True)
+        try:
+            QtWidgets.QMessageBox.critical(
+                None, "Application Startup Error", f"Failed to create startup manager:\n{e}\n\nSee logs."
+            )
+        except Exception:
+            pass
+        sys.exit(1)
+
+    # Start Qt Event Loop
+    log.debug("Starting Qt event loop...")
+    exit_code = app.exec()
+    log.debug(f"Qt event loop finished with exit code {exit_code}.")
+    return exit_code
+
+
+# Allow direct execution for development and testing
+if __name__ == "__main__":
+    run_gui()

Synaptipy/application/cli/__init__.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+"""
+Command-Line Interface (CLI) subpackage for Synaptipy.
+
+This module is reserved for future CLI functionality.
+The primary interface is the GUI, launched via ``synaptipy`` or
+``python -m Synaptipy.application``.
+"""
+
+__all__: list = []
+__all__ = []

Synaptipy/application/cli/main.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+Command-Line Interface (CLI) entry point for Synaptipy.
+
+Reserved for future implementation. The primary interface is currently
+the GUI application.
+"""
+
+# Future CLI implementation using argparse or click.
+# See docs/developer_guide.md for planned CLI features.

Synaptipy/application/controllers/__init__.py

@@ -0,0 +1,19 @@
+"""Application controllers for Synaptipy."""
+
+from .analysis_formatter import AnalysisResultFormatter, generate_methods_text
+from .analysis_plot_manager import AnalysisPlotManager, PlotContextTrace, PlotDataPackage
+from .file_io_controller import FileIOController
+from .live_analysis_controller import AnalysisRunnable, LiveAnalysisController
+from .shortcut_manager import ShortcutManager
+
+__all__ = [
+    "AnalysisResultFormatter",
+    "generate_methods_text",
+    "AnalysisPlotManager",
+    "PlotContextTrace",
+    "PlotDataPackage",
+    "FileIOController",
+    "AnalysisRunnable",
+    "LiveAnalysisController",
+    "ShortcutManager",
+]