scitex 2.5.0__py3-none-any.whl → 2.7.3__py3-none-any.whl

scitex/bridge/_stats_vis.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: ./src/scitex/bridge/_stats_vis.py
+# Time-stamp: "2024-12-09 10:00:00 (ywatanabe)"
+"""
+Bridge module for stats ↔ vis integration.
+
+Provides adapters to:
+- Convert StatResult to vis AnnotationModel
+- Add statistical annotations to FigureModel
+- Position stat annotations using vis coordinate system
+
+Coordinate Convention
+---------------------
+This module uses **data coordinates** for positioning (via Position with
+unit="data"). This matches the vis model's approach where positions
+correspond to actual data values on the plot.
+
+- Positions are in the same units as the plot data
+- position_stat_annotation() returns Position(unit="data")
+- For normalized positioning, use axes_bounds to define the data range
+
+This differs from _stats_plt which uses axes coordinates (0-1 normalized).
+When bridging between plt and vis, coordinate transformation may be needed.
+"""
+
+from typing import Optional, Dict, Any, List, Tuple
+
+from scitex.schema import StatResult, Position, StatPositioning
+from scitex.fig.model import AnnotationModel, FigureModel, AxesModel, TextStyle
+
+
+def stat_result_to_annotation(
+    stat_result: StatResult,
+    format_style: str = "asterisk",
+    x: Optional[float] = None,
+    y: Optional[float] = None,
+) -> AnnotationModel:
+    """
+    Convert a StatResult to a vis AnnotationModel.
+
+    Parameters
+    ----------
+    stat_result : StatResult
+        The statistical result to convert
+    format_style : str
+        Format style for the text ("asterisk", "compact", "detailed", "publication")
+    x : float, optional
+        X position (data coordinates). Overrides stat_result positioning
+    y : float, optional
+        Y position (data coordinates). Overrides stat_result positioning
+
+    Returns
+    -------
+    AnnotationModel
+        Annotation model for vis rendering
+    """
+    # Get formatted text
+    text = stat_result.format_text(format_style)
+
+    # Determine position
+    if x is None or y is None:
+        positioning = stat_result.positioning
+        if positioning and positioning.position:
+            pos = positioning.position
+            x = x if x is not None else pos.x
+            y = y if y is not None else pos.y
+        else:
+            # Default center-top position (will be overridden by positioning logic)
+            x = x if x is not None else 0.5
+            y = y if y is not None else 0.95
+
+    # Build text style from stat styling
+    styling = stat_result.styling
+    text_style = TextStyle(
+        fontsize=styling.font_size_pt if styling else 7.0,
+        color=styling.color if styling else "#000000",
+        ha="center",
+        va="top",
+    )
+
+    # Create annotation model
+    return AnnotationModel(
+        annotation_type="text",
+        text=text,
+        x=x,
+        y=y,
+        annotation_id=stat_result.plot_id or f"stat_{id(stat_result)}",
+        style=text_style,
+    )
+
+
+def add_stats_to_figure_model(
+    figure_model: FigureModel,
+    stat_results: List[StatResult],
+    axes_index: int = 0,
+    format_style: str = "asterisk",
+    auto_position: bool = True,
+) -> FigureModel:
+    """
+    Add statistical results as annotations to a FigureModel.
+
+    Parameters
+    ----------
+    figure_model : FigureModel
+        The figure model to annotate
+    stat_results : List[StatResult]
+        List of statistical results to add
+    axes_index : int
+        Index of axes to add annotations to
+    format_style : str
+        Format style for the text
+    auto_position : bool
+        Whether to automatically position stats to avoid overlap
+
+    Returns
+    -------
+    FigureModel
+        The modified figure model (same instance)
+    """
+    if not stat_results:
+        return figure_model
+
+    # Ensure axes exist
+    if axes_index >= len(figure_model.axes):
+        raise IndexError(f"Axes index {axes_index} out of range")
+
+    axes_dict = figure_model.axes[axes_index]
+
+    # Get or initialize annotations list
+    if "annotations" not in axes_dict:
+        axes_dict["annotations"] = []
+
+    # Calculate positions if auto_position
+    positions = []
+    if auto_position:
+        positions = _calculate_stat_positions(
+            stat_results,
+            len(axes_dict["annotations"]),
+        )
+
+    # Add each stat as annotation
+    for i, stat_result in enumerate(stat_results):
+        x, y = positions[i] if positions else (None, None)
+        annotation = stat_result_to_annotation(
+            stat_result,
+            format_style=format_style,
+            x=x,
+            y=y,
+        )
+        axes_dict["annotations"].append(annotation.to_dict())
+
+    return figure_model
+
+
+def position_stat_annotation(
+    stat_result: StatResult,
+    axes_bounds: Dict[str, float],
+    existing_positions: Optional[List[Tuple[float, float]]] = None,
+    preferred_corner: str = "top-right",
+) -> Position:
+    """
+    Calculate optimal position for a stat annotation.
+
+    Parameters
+    ----------
+    stat_result : StatResult
+        The statistical result to position
+    axes_bounds : Dict[str, float]
+        Axes bounds with keys: x_min, x_max, y_min, y_max
+    existing_positions : List[Tuple[float, float]], optional
+        List of existing annotation positions to avoid
+    preferred_corner : str
+        Preferred corner: "top-left", "top-right", "bottom-left", "bottom-right"
+
+    Returns
+    -------
+    Position
+        Calculated position in data coordinates
+    """
+    existing = existing_positions or []
+
+    # Get axes range
+    x_min = axes_bounds.get("x_min", 0)
+    x_max = axes_bounds.get("x_max", 1)
+    y_min = axes_bounds.get("y_min", 0)
+    y_max = axes_bounds.get("y_max", 1)
+
+    x_range = x_max - x_min
+    y_range = y_max - y_min
+
+    # Calculate corner positions (as fraction, then convert to data)
+    corner_fractions = {
+        "top-right": (0.95, 0.95),
+        "top-left": (0.05, 0.95),
+        "bottom-right": (0.95, 0.05),
+        "bottom-left": (0.05, 0.05),
+        "top-center": (0.5, 0.95),
+        "bottom-center": (0.5, 0.05),
+    }
+
+    # Start with preferred corner
+    base_x, base_y = corner_fractions.get(preferred_corner, (0.95, 0.95))
+    x = x_min + base_x * x_range
+    y = y_min + base_y * y_range
+
+    # Check overlap and adjust if needed
+    min_dist = stat_result.positioning.min_distance_mm if stat_result.positioning else 2.0
+
+    for ex_x, ex_y in existing:
+        dist = ((x - ex_x) ** 2 + (y - ex_y) ** 2) ** 0.5
+        if dist < min_dist:
+            # Shift down
+            y -= min_dist * 1.5
+
+    return Position(x=x, y=y, unit="data")
+
+
+def _calculate_stat_positions(
+    stat_results: List[StatResult],
+    existing_count: int = 0,
+) -> List[Tuple[float, float]]:
+    """
+    Calculate non-overlapping positions for multiple stats.
+
+    Parameters
+    ----------
+    stat_results : List[StatResult]
+        List of stats to position
+    existing_count : int
+        Number of existing annotations
+
+    Returns
+    -------
+    List[Tuple[float, float]]
+        List of (x, y) positions in axes coordinates (0-1)
+    """
+    positions = []
+    y_start = 0.95
+    y_step = 0.05
+
+    for i, stat in enumerate(stat_results):
+        # Stack vertically from top
+        y = y_start - (i + existing_count) * y_step
+        x = 0.5  # Center
+
+        # Check stat's own positioning preference
+        if stat.positioning and stat.positioning.position:
+            pos = stat.positioning.position
+            x = pos.x
+            y = pos.y
+
+        positions.append((x, y))
+
+    return positions
+
+
+__all__ = [
+    "stat_result_to_annotation",
+    "add_stats_to_figure_model",
+    "position_stat_annotation",
+]
+
+
+# EOF

scitex/browser/__init__.py

@@ -84,11 +84,9 @@ __all__ = [
     "SyncBrowserSession",
     "sync_browser_session",
     "create_browser_session_fixture",
-
     # PDF
     "detect_chrome_pdf_viewer_async",
     "click_download_for_chrome_pdf_viewer_async",
-
     # Interaction
     "click_center_async",
     "click_with_fallbacks_async",

scitex/browser/auth/google.py

@@ -90,8 +90,8 @@ class GoogleAuthHelper:
                 alternatives = [
                     'button:has-text("Google")',
                     '[data-testid="google-login"]',
-                    'button >> text=Continue with Google',
-                    'button >> text=Sign in with Google',
+                    "button >> text=Continue with Google",
+                    "button >> text=Sign in with Google",
                 ]
                 for selector in alternatives:
                     try:
@@ -178,14 +178,16 @@ class GoogleAuthHelper:
         """Fill email on Google login page."""
         try:
             # Wait for email input
-            await popup.wait_for_selector('input[type="email"]', state="visible", timeout=10000)
+            await popup.wait_for_selector(
+                'input[type="email"]', state="visible", timeout=10000
+            )
 
             self._log(f"Filling email: {self.email}")
             await popup.fill('input[type="email"]', self.email)
             await popup.wait_for_timeout(500)
 
             # Click Next button
-            next_btn = await popup.query_selector('#identifierNext')
+            next_btn = await popup.query_selector("#identifierNext")
             if not next_btn:
                 next_btn = await popup.query_selector('button:has-text("Next")')
 
@@ -210,9 +212,7 @@ class GoogleAuthHelper:
 
             # Wait for password input to become visible
             await popup.wait_for_selector(
-                'input[type="password"]',
-                state="visible",
-                timeout=15000
+                'input[type="password"]', state="visible", timeout=15000
             )
 
             self._log("Filling password")
@@ -220,7 +220,7 @@ class GoogleAuthHelper:
             await popup.wait_for_timeout(500)
 
             # Click Next button
-            next_btn = await popup.query_selector('#passwordNext')
+            next_btn = await popup.query_selector("#passwordNext")
             if not next_btn:
                 next_btn = await popup.query_selector('button:has-text("Next")')
 
@@ -253,7 +253,7 @@ class GoogleAuthHelper:
             continue_selectors = [
                 'button:has-text("Continue")',
                 'button:has-text("Allow")',
-                '#submit_approve_access',
+                "#submit_approve_access",
                 'button[data-idom-class*="continue"]',
             ]
 
@@ -295,7 +295,9 @@ class GoogleAuthHelper:
                 "Check your phone",
             ]
 
-            is_2fa = any(indicator.lower() in page_text.lower() for indicator in twofa_indicators)
+            is_2fa = any(
+                indicator.lower() in page_text.lower() for indicator in twofa_indicators
+            )
 
             if is_2fa:
                 self._log("2FA detected - waiting for user approval...")
@@ -311,7 +313,10 @@ class GoogleAuthHelper:
                     # Check if popup closed
                     try:
                         current_url = popup.url
-                        if current_url != start_url and "accounts.google.com" not in current_url:
+                        if (
+                            current_url != start_url
+                            and "accounts.google.com" not in current_url
+                        ):
                             self._log("2FA completed - redirected")
                             return True
                     except:

scitex/browser/automation/CookieHandler.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/browser/automation/CookieHandler.py"
-)
+
+__FILE__ = "./src/scitex/browser/automation/CookieHandler.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 

scitex/browser/collaboration/__init__.py

@@ -39,6 +39,7 @@ __all__ = [
     "google_login",
 ]
 
+
 # Compatibility check - ensure we don't break existing code
 def _check_compatibility():
     """Verify existing scitex.browser still works."""
@@ -46,6 +47,7 @@ def _check_compatibility():
         from scitex.browser import browser_logger
         from scitex.browser.automation import CookieAutoAcceptor
         from scitex.browser.interaction import click_center_async
+
         return True
     except ImportError as e:
         raise RuntimeError(
@@ -53,6 +55,7 @@ def _check_compatibility():
             "This should never happen! Please report this bug."
         )
 
+
 _check_compatibility()
 
 print("✅ scitex.browser.collaboration loaded (experimental)")

scitex/browser/collaboration/auth_helpers.py

@@ -86,7 +86,9 @@ class DjangoAuthHelper:
         is_logged_in = "login" not in current_url.lower()
         return is_logged_in
 
-    async def logout(self, page: Page, logout_url: str = "http://127.0.0.1:8000/auth/logout/"):
+    async def logout(
+        self, page: Page, logout_url: str = "http://127.0.0.1:8000/auth/logout/"
+    ):
         """Logout (navigate to logout URL)."""
         await page.goto(logout_url)
 

scitex/browser/collaboration/collaborative_agent.py

@@ -61,9 +61,11 @@ class CollaborativeAgent:
 
     def on_input(self, key: str):
         """Decorator to register handler for input."""
+
         def decorator(func: Callable):
             self.handlers[key] = func
             return func
+
         return decorator
 
     def on_url_change(self, func: Callable):

scitex/browser/collaboration/interactive_panel.py

@@ -67,13 +67,13 @@ class InteractivePanel:
     def _load_persistent_memory(self):
         """Load persistent memory from disk."""
         if self.persistent_memory_file.exists():
-            with open(self.persistent_memory_file, 'r') as f:
+            with open(self.persistent_memory_file, "r") as f:
                 self.session_memory = json.load(f)
 
     def _save_persistent_memory(self):
         """Save persistent memory to disk."""
         if self.enable_persistence:
-            with open(self.persistent_memory_file, 'w') as f:
+            with open(self.persistent_memory_file, "w") as f:
                 json.dump(self.session_memory, f, indent=2)
 
     async def initialize(self):

scitex/browser/collaboration/shared_session.py

@@ -100,7 +100,9 @@ class SharedBrowserSession:
             user_data_dir = self.config.user_data_dir
         else:
             scitex_dir = Path(os.getenv("SCITEX_DIR", Path.home() / ".scitex"))
-            user_data_dir = str(scitex_dir / "browser" / "sessions" / self.config.session_id)
+            user_data_dir = str(
+                scitex_dir / "browser" / "sessions" / self.config.session_id
+            )
 
         # Start playwright
         self.playwright = await async_playwright().start()
@@ -124,10 +126,13 @@ class SharedBrowserSession:
         self.start_time = time.time()
 
         # Log event
-        self._log_event("session_started", {
-            "session_id": self.config.session_id,
-            "user_data_dir": user_data_dir,
-        })
+        self._log_event(
+            "session_started",
+            {
+                "session_id": self.config.session_id,
+                "user_data_dir": user_data_dir,
+            },
+        )
 
         print(f"✅ Shared browser session started: {self.config.session_id}")
         print(f"   User data: {user_data_dir}")
@@ -137,7 +142,9 @@ class SharedBrowserSession:
         if self.config.screenshot_interval:
             asyncio.create_task(self._auto_screenshot_loop())
 
-    async def navigate(self, url: str, wait_until: str = "load", timeout: int = 60000) -> str:
+    async def navigate(
+        self, url: str, wait_until: str = "load", timeout: int = 60000
+    ) -> str:
         """
         Navigate to URL.
 
@@ -225,10 +232,13 @@ class SharedBrowserSession:
 
         duration = time.time() - self.start_time if self.start_time else 0
 
-        self._log_event("session_closed", {
-            "duration": duration,
-            "screenshot_count": len(self.screenshots),
-        })
+        self._log_event(
+            "session_closed",
+            {
+                "duration": duration,
+                "screenshot_count": len(self.screenshots),
+            },
+        )
 
         print(f"✅ Shared browser session closed: {self.config.session_id}")
         print(f"   Duration: {duration:.1f}s")
@@ -380,4 +390,3 @@ class SharedBrowserSession:
 
 
 # EOF
-

scitex/browser/collaboration/standard_interactions.py

@@ -16,6 +16,7 @@ from playwright.async_api import Page
 
 class UserResponse(Enum):
     """Standardized user responses."""
+
     YES = "yes"
     NO = "no"
     ACCEPT = "accept"

scitex/browser/core/BrowserMixin.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -45,10 +46,7 @@ class BrowserMixin:
     @classmethod
     async def get_shared_browser_async(cls) -> Browser:
         """Get or create shared browser instance (deprecated - use get_browser_async)."""
-        if (
-            cls._shared_browser is None
-            or cls._shared_browser.is_connected() is False
-        ):
+        if cls._shared_browser is None or cls._shared_browser.is_connected() is False:
             if cls._shared_playwright is None:
                 cls._shared_playwright = await async_playwright().start()
             cls._shared_browser = await cls._shared_playwright.chromium.launch(
@@ -69,10 +67,7 @@ class BrowserMixin:
 
     async def get_browser_async(self) -> Browser:
         """Get or create a local browser instance with the current mode setting."""
-        if (
-            self._shared_browser is None
-            or self._shared_browser.is_connected() is False
-        ):
+        if self._shared_browser is None or self._shared_browser.is_connected() is False:
             if self._shared_playwright is None:
                 self._shared_playwright = await async_playwright().start()
 
@@ -108,11 +103,9 @@ class BrowserMixin:
 
             # Always run in visible mode (never headless)
             # This is safer for bot detection while providing flexibility via viewport sizing
-            self._shared_browser = (
-                await self._shared_playwright.chromium.launch(
-                    headless=False,
-                    args=stealth_args,
-                )
+            self._shared_browser = await self._shared_playwright.chromium.launch(
+                headless=False,
+                args=stealth_args,
             )
         return self._shared_browser
 
@@ -120,9 +113,7 @@ class BrowserMixin:
         """Create new page/tab and optionally navigate to URL."""
         browser = await self.get_browser_async()
         context = await browser.new_context()
-        await context.add_init_script(
-            self.cookie_acceptor.get_auto_acceptor_script()
-        )
+        await context.add_init_script(self.cookie_acceptor.get_auto_acceptor_script())
         # await self.cookie_acceptor.inject_auto_acceptor_async(context)
         page = await context.new_page()
         self.contexts.append(context)
@@ -151,9 +142,7 @@ class BrowserMixin:
         """Create browser context with cookie auto-acceptance."""
         # Use headless mode for stealth, visible for interactive
         is_headless = self.mode == "stealth"
-        browser = await playwright_instance.chromium.launch(
-            headless=is_headless
-        )
+        browser = await playwright_instance.chromium.launch(headless=is_headless)
 
         # # Smart viewport sizing based on mode
         # if "viewport" not in context_options:
@@ -165,15 +154,11 @@ class BrowserMixin:
         #         context_options["viewport"] = {"width": 1280, "height": 720}
 
         context = await browser.new_context(**context_options)
-        await context.add_init_script(
-            self.cookie_acceptor.get_auto_acceptor_script()
-        )
+        await context.add_init_script(self.cookie_acceptor.get_auto_acceptor_script())
         # await self.cookie_acceptor.inject_auto_acceptor_async(context)
         return browser, context
 
-    async def get_session_async(
-        self, timeout: int = 30
-    ) -> aiohttp.ClientSession:
+    async def get_session_async(self, timeout: int = 30) -> aiohttp.ClientSession:
         """Get or create basic aiohttp session."""
         if (
             not hasattr(self, "_session")
@@ -189,11 +174,7 @@ class BrowserMixin:
 
     async def close_session(self):
         """Close the aiohttp session."""
-        if (
-            hasattr(self, "_session")
-            and self._session
-            and not self._session.closed
-        ):
+        if hasattr(self, "_session") and self._session and not self._session.closed:
             await self._session.close()
             self._session = None
 
@@ -281,6 +262,7 @@ def main(args):
 def parse_args():
     """Parse command line arguments."""
     import argparse
+
     parser = argparse.ArgumentParser(description="BrowserMixin demo")
     return parser.parse_args()