cubevis 0.5.19__tar.gz → 0.5.20__tar.gz

{cubevis-0.5.19 → cubevis-0.5.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cubevis
-Version: 0.5.19
+Version: 0.5.20
 Summary: visualization toolkit and apps for casa
 License: LGPL
 Author-email: Darrell Schiebel <darrell@schiebel.us>,Pam Harris <pharris@nrao.edu>

{cubevis-0.5.19 → cubevis-0.5.20}/cubevis/__init__.py

@@ -29,11 +29,33 @@
 used to build GUI applications for astronomy. It also contains some
 applications turn-key applications'''
 
-import os as __os
+import os as _os
+import logging as _logging
 
+logger = _logging.getLogger('cubevis')
+_handler = _logging.StreamHandler()
+_formatter = _logging.Formatter('[%(name)s] %(levelname)s: %(message)s')
+_handler.setFormatter(_formatter)
+logger.addHandler(_handler)
+
+if _os.getenv('CUBEVIS_DEBUG', '').lower() in ('1', 'true', 'yes', 'on'):
+    logger.setLevel(_logging.DEBUG)
+else:
+    logger.setLevel(_logging.INFO)
 
 from .private.apps import iclean
 
+
+def set_log_level(level):
+    """Set the logging level for cubevis.
+
+    Args:
+        level: Logging level (e.g., logging.DEBUG, logging.INFO, 'DEBUG', 'INFO')
+    """
+    if isinstance(level, str):
+        level = getattr(_logging, level.upper())
+    logger.setLevel(level)
+
 try:
     from .__version__ import __version__
 except ModuleNotFoundError:
@@ -52,7 +74,7 @@ def xml_interface_defs( ):
     '''
     return { }
 
-__mustache_interface_templates__ = { 'iclean': __os.path.join( __os.path.dirname(__file__), "private", "casashell", "iclean.mustache" ) }
+__mustache_interface_templates__ = { 'iclean': _os.path.join( _os.path.dirname(__file__), "private", "casashell", "iclean.mustache" ) }
 def mustache_interface_templates( ):
     '''This provides a list of mustache files provided by cubevis. It may eventually allow
        casashell to generate all of its bindings at startup time. This would allow casashell

cubevis-0.5.20/cubevis/exe/__init__.py

@@ -0,0 +1,4 @@
+from ._mode import Mode
+from ._setting import Setting
+from ._task import Task
+from ._context import Context

cubevis-0.5.20/cubevis/exe/_context.py

@@ -0,0 +1,126 @@
+import asyncio
+import logging
+import threading
+from typing import Optional, Union, Any, Callable
+from concurrent.futures import ThreadPoolExecutor, Future
+
+from . import Mode, Task
+
+logger = logging.getLogger(__name__)
+
+class Context:
+    """Unified interface for different execution contexts with lifecycle management."""
+
+    def __init__(self, mode: Mode, executor: Optional[ThreadPoolExecutor] = None):
+        logger.debug( f"\tContext::__init__({mode},{executor} ): {id(self)}" )
+        self.mode = mode
+        self.executor = executor or ThreadPoolExecutor(max_workers=4)
+        self._running_tasks = []
+        self._stop_events = {}
+
+    def create_stop_condition( self, task_id: Optional[str] = None,
+                               prefer_asyncio: bool = False ):
+        """Create appropriate stop condition for the execution mode."""
+        logger.debug( f"\tContext::create_stop_condition({task_id}): {id(self)}" )
+        if task_id is None:
+            task_id = f"task_{len(self._stop_events)}"
+
+        if prefer_asyncio or self.mode in [ExecutionMode.ASYNC_RUN, ExecutionMode.ASYNC_TASK]:
+            # For async contexts, use asyncio primitives
+            event = asyncio.Event()
+        else:
+            # ====>> if self.mode in [Mode.SYNC, Mode.THREAD]: <<====
+            # For threading contexts, always use threading primitives
+            condition = threading.Condition()
+            condition.stop_requested = False
+
+            def stop_task():
+                with condition:
+                    condition.stop_requested = True
+                    condition.notify_all()
+
+            condition.stop_task = stop_task
+            event = condition
+
+        self._stop_events[task_id] = event
+        return event, task_id
+
+    def stop_task(self, task_id: str):
+        """Signal a task to stop."""
+        if task_id in self._stop_events:
+            condition_or_event = self._stop_events[task_id]
+            if isinstance(condition_or_event, threading.Condition):
+                logger.debug( f"\tContext::stop_task({task_id}): {id(self)} - condition" )
+                condition_or_event.stop_task()
+            elif hasattr(condition_or_event, 'set'):  # Both threading.Event and asyncio.Event have set()
+                logger.debug( f"\tContext::stop_task({task_id}): {id(self)} - event" )
+                condition_or_event.set()
+            else:
+                # Fallback for other types
+                logger.debug(f"Warning: Unknown stop condition type: {type(condition_or_event)}")
+
+    def stop_all_tasks(self):
+        """Signal all tasks to stop."""
+        logger.debug( f"\tContext::stop_all_task( ): {id(self)}" )
+        for condition_or_event in self._stop_events.values():
+            if isinstance(condition_or_event, threading.Condition):
+                condition_or_event.stop_task()
+            elif hasattr(condition_or_event, 'set'):  # Both threading.Event and asyncio.Event have set()
+                condition_or_event.set()
+            else:
+                logger.debug(f"Warning: Unknown stop condition type: {type(condition_or_event)}")
+
+    def execute(self, task: Task, task_id: Optional[str] = None) -> Union[Any, Future, asyncio.Task]:
+        """Execute Bokeh task according to the configured mode."""
+
+        if self.mode == Mode.SYNC:
+            logger.debug( f"\tContext::execute({task},{task_id} ): {id(self)} - sync" )
+            return task.run_sync()
+
+        elif self.mode == Mode.ASYNC_RUN:
+            logger.debug( f"\tContext::execute({task},{task_id} ): {id(self)} - async" )
+            if asyncio.iscoroutinefunction(task.server_func):
+                return asyncio.run(task.run_async())
+            else:
+                async def async_wrapper():
+                    return await task.run_async()
+                return asyncio.run(async_wrapper())
+
+        elif self.mode == Mode.ASYNC_TASK:
+            logger.debug( f"\tContext::execute({task},{task_id} ): {id(self)} - task" )
+            try:
+                loop = asyncio.get_running_loop()
+                async_task = loop.create_task(task.run_async())
+                if task_id:
+                    self._running_tasks.append((task_id, async_task))
+                return async_task
+            except RuntimeError:
+                raise RuntimeError("ASYNC_TASK mode requires an active event loop")
+
+        elif self.mode == Mode.THREAD:
+            logger.debug( f"\tContext::execute({task},{task_id} ): {id(self)} - thread" )
+            future = self.executor.submit(task.run_sync)
+            if task_id:
+                self._running_tasks.append((task_id, future))
+            return future
+
+    async def execute_async(self, task: Task, task_id: Optional[str] = None) -> Any:
+        """Async version that always returns the result."""
+
+        if self.mode == Mode.SYNC:
+            logger.debug( f"\tContext::execute_async({task},{task_id} ): {id(self)} - sync" )
+            loop = asyncio.get_running_loop()
+            return await loop.run_in_executor(self.executor, task.run_sync)
+
+        elif self.mode == Mode.ASYNC_RUN:
+            logger.debug( f"\tContext::execute_async({task},{task_id} ): {id(self)} - async" )
+            return await task.run_async()
+
+        elif self.mode == Mode.ASYNC_TASK:
+            logger.debug( f"\tContext::execute_async({task},{task_id} ): {id(self)} - task" )
+            return await task.run_async()
+
+        elif self.mode == Mode.THREAD:
+            logger.debug( f"\tContext::execute_async({task},{task_id} ): {id(self)} - thread" )
+            loop = asyncio.get_running_loop()
+            return await loop.run_in_executor(self.executor, task.run_sync)

cubevis-0.5.20/cubevis/exe/_mode.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class Mode(Enum):
+    SYNC = "sync"
+    ASYNC_RUN = "async_run"
+    ASYNC_TASK = "async_task"
+    THREAD = "thread"

cubevis-0.5.20/cubevis/exe/_setting.py

@@ -0,0 +1,4 @@
+from enum import Enum
+
+class Setting(Enum):
+    CLI = "python_cli"

cubevis-0.5.20/cubevis/exe/_task.py

@@ -0,0 +1,230 @@
+import logging
+import asyncio
+import threading
+from typing import Callable, Optional, Union, Any
+
+logger = logging.getLogger(__name__)
+
+class Task:
+    """A long-running Bokeh backend task that runs until completion or stop signal.
+    """
+
+    def __init__(self,
+                 server_func: Callable,
+                 *args,
+                 stop_condition: Optional[Union[threading.Event, asyncio.Event, threading.Condition, Callable[[], bool]]] = None,
+                 **kwargs):
+        """
+        Args:
+            server_func: Function that starts the Bokeh server (sync or async)
+            stop_condition: Event or callable that signals when to stop
+                - threading.Event: for thread-based execution
+                - asyncio.Event: for async execution
+                - threading.Condition: for complex condition-based stopping (most flexible)
+                - Callable[[], bool]: function returning True when should stop
+                - None: runs until server_func returns naturally
+        """
+        logger.debug( f"\tTask::__init__({server_func},{args},{stop_condition},{kwargs}): {id(self)}" )
+        self.server_func = server_func
+        self.args = args
+        self.kwargs = kwargs
+        self.stop_condition = stop_condition
+        self._result = None
+        self._exception = None
+
+    def _convert_asyncio_event_to_threading(self, asyncio_event):
+        """Convert asyncio.Event to threading.Event for sync contexts."""
+        threading_event = threading.Event()
+        logger.debug( f"\tTask::_convert_asyncio_event_to_threading({asyncio_event}): {id(self)}" )
+        
+        # Create a bridge between asyncio.Event and threading.Event
+        # We'll use a background thread with its own event loop to monitor the asyncio event
+        def bridge_events():
+            # Create a new event loop for this thread
+            try:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                
+                async def wait_and_set():
+                    await asyncio_event.wait()
+                    threading_event.set()
+                
+                loop.run_until_complete(wait_and_set())
+            except Exception as e:
+                # If bridging fails, fall back to a simple timeout approach
+                print(f"Warning: Event bridging failed: {e}")
+                time.sleep(0.1)  # Small delay to prevent tight loop
+                threading_event.set()  # Set it anyway to unblock
+            finally:
+                try:
+                    loop.close()
+                except:
+                    pass
+        
+        # Start the bridge in a daemon thread
+        bridge_thread = threading.Thread(target=bridge_events, daemon=True)
+        bridge_thread.start()
+        
+        return threading_event
+
+    def run_sync(self) -> Any:
+        """Run synchronously until completion or stop signal."""
+        if self.stop_condition is None:
+            # Handle async functions in sync context
+            if asyncio.iscoroutinefunction(self.server_func):
+                logger.debug( f"\tTask::run_sync( ): {id(self)} - asyncio no stop condition {self.server_func}" )
+                return asyncio.run(self.server_func(*self.args, **self.kwargs))
+            else:
+                logger.debug( f"\tTask::run_sync( ): {id(self)} - no stop condition {self.server_func}" )
+                return self.server_func(*self.args, **self.kwargs)
+
+        # Handle asyncio.Event in sync context by converting to threading.Event
+        stop_condition = self.stop_condition
+        if isinstance(self.stop_condition, asyncio.Event):
+            logger.debug( f"\tTask::run_sync( ): {id(self)} - asyncio bridge {self.server_func}" )
+            # Convert asyncio.Event to threading.Event for sync execution
+            stop_condition = self._convert_asyncio_event_to_threading(self.stop_condition)
+        
+        if callable(stop_condition):
+            # Poll-based stopping
+            logger.debug( f"\tTask::run_sync( ): {id(self)} - polling {self.server_func}" )
+            while not stop_condition():
+                try:
+                    if asyncio.iscoroutinefunction(self.server_func):
+                        result = asyncio.run(self.server_func(*self.args, **self.kwargs))
+                    else:
+                        result = self.server_func(*self.args, **self.kwargs)
+                    if result is not None:  # Server function completed
+                        return result
+                except Exception as e:
+                    self._exception = e
+                    raise
+
+        elif isinstance(stop_condition, threading.Event):
+            # Event-based stopping for threads
+            logger.debug( f"\tTask::run_sync( ): {id(self)} - threading event {self.server_func}" )
+            def run_with_check():
+                while not stop_condition.is_set():
+                    try:
+                        if asyncio.iscoroutinefunction(self.server_func):
+                            result = asyncio.run(self.server_func(*self.args, **self.kwargs))
+                        else:
+                            result = self.server_func(*self.args, **self.kwargs)
+                        if result is not None:
+                            return result
+                    except Exception as e:
+                        self._exception = e
+                        raise
+            return run_with_check()
+
+        elif isinstance(stop_condition, threading.Condition):
+            logger.debug( f"\tTask::run_sync( ): {id(self)} - threading condition {self.server_func}" )
+            # Condition-based stopping - most flexible and efficient
+            def run_with_condition():
+                with stop_condition:
+                    while True:
+                        # Check if we should stop (condition should have a flag or predicate)
+                        # The condition object should be used by external code to signal stopping
+                        # We'll pass the condition to the server function so it can wait efficiently
+                        try:
+                            # Pass the condition to the server function if it accepts it
+                            import inspect
+                            sig = inspect.signature(self.server_func)
+                            if 'stop_condition' in sig.parameters:
+                                if asyncio.iscoroutinefunction(self.server_func):
+                                    result = asyncio.run(self.server_func(*self.args, stop_condition=stop_condition, **self.kwargs))
+                                else:
+                                    result = self.server_func(*self.args, stop_condition=stop_condition, **self.kwargs)
+                            else:
+                                if asyncio.iscoroutinefunction(self.server_func):
+                                    result = asyncio.run(self.server_func(*self.args, **self.kwargs))
+                                else:
+                                    result = self.server_func(*self.args, **self.kwargs)
+
+                            if result is not None:
+                                return result
+
+                            # If function returns None, wait for condition change
+                            stop_condition.wait()
+
+                        except Exception as e:
+                            self._exception = e
+                            raise
+
+            return run_with_condition()
+
+        else:
+            raise ValueError(f"Invalid stop_condition ({type(stop_condition)}) for sync execution")
+
+    async def run_async(self) -> Any:
+        """Run asynchronously until completion or stop signal."""
+        if asyncio.iscoroutinefunction(self.server_func):
+            if self.stop_condition is None:
+                logger.debug( f"\tTask::run_async( ): {id(self)} - no stop condition {self.server_func}" )
+                return await self.server_func(*self.args, **self.kwargs)
+
+            if callable(self.stop_condition):
+                # Poll-based stopping
+                logger.debug( f"\tTask::run_async( ): {id(self)} - polling {self.server_func}" )
+                while not self.stop_condition():
+                    try:
+                        # Run server function as task so we can check stop condition
+                        task = asyncio.create_task(self.server_func(*self.args, **self.kwargs))
+
+                        # Check stop condition periodically
+                        while not task.done() and not self.stop_condition():
+                            await asyncio.sleep(0.1)
+
+                        if self.stop_condition():
+                            task.cancel()
+                            try:
+                                await task
+                            except asyncio.CancelledError:
+                                pass
+                            return None
+
+                        return await task
+                    except Exception as e:
+                        self._exception = e
+                        raise
+
+            elif isinstance(self.stop_condition, asyncio.Event):
+                logger.debug( f"\tTask::run_async( ): {id(self)} - asyncio event {self.server_func}" )
+                # Event-based stopping for async
+                server_task = asyncio.create_task(self.server_func(*self.args, **self.kwargs))
+                stop_task = asyncio.create_task(self.stop_condition.wait())
+
+                done, pending = await asyncio.wait(
+                    [server_task, stop_task],
+                    return_when=asyncio.FIRST_COMPLETED
+                )
+
+                # Cancel remaining tasks
+                for task in pending:
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
+
+                if server_task in done:
+                    return server_task.result()
+                else:
+                    return None  # Stopped by event
+
+            elif isinstance(self.stop_condition, threading.Condition):
+                logger.debug( f"\tTask::run_async( ): {id(self)} - threading condition {self.server_func}" )
+                # For async context with threading.Condition, we need to run in executor
+                # since threading.Condition is synchronous
+                loop = asyncio.get_event_loop()
+                return await loop.run_in_executor(None, self.run_sync)
+
+            else:
+                raise ValueError("Invalid stop_condition for async execution")
+
+        else:
+            logger.debug( f"\tTask::run_async( ): {id(self)} - until completion" )
+            # Sync function in async context - run in thread pool
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(None, self.run_sync)
+

cubevis-0.5.20/cubevis/private/apps/_interactiveclean.mustache

@@ -0,0 +1,89 @@
+########################################################################
+#
+#TASK XML> tclean -argfilter=interactive,fullsummary -argfilter:initParams=vis,imagename
+# Copyright (C) 2022,2023,2024,2025
+# Associated Universities, Inc. Washington DC, USA.
+#
+# This script is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Library General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This library is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Library General Public License
+# along with this library; if not, write to the Free Software Foundation,
+# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+#
+# Correspondence concerning AIPS++ should be adressed as follows:
+#        Internet email: casa-feedback@nrao.edu.
+#        Postal address: AIPS++ Project Office
+#                        National Radio Astronomy Observatory
+#                        520 Edgemont Road
+#                        Charlottesville, VA 22903-2475 USA
+#
+########################################################################
+'''implementation of the ``InteractiveClean`` application for interactive control
+of tclean'''
+
+from pprint import pprint
+
+import sys
+from os.path import exists
+from casatasks.private.imagerhelpers.input_parameters import ImagerParameters
+
+from cubevis.utils import find_pkg, load_pkg
+from cubevis.toolbox import InteractiveCleanUI
+from cubevis import exe
+
+class InteractiveClean:
+    '''InteractiveClean(...) implements interactive clean using Bokeh
+    {{docstring}}
+    '''
+
+    def __init__( self, vis, imagename{{# initParams}}, {{name}}={{default}}{{/ initParams}}, iclean_backend="PROD" ):
+
+
+        ###
+        ### iclean_backend can be used to select alternate backends for interactive clean. This could be used
+        ### to enable a backend with extended features or it could be used to select a stub backend designed
+        ### for testing
+        ###
+        mod_specs = None
+        self._gclean_module = None
+        if iclean_backend == 'PROD':
+            mod_specs = find_pkg( "casatasks.private.imagerhelpers._gclean" )
+        else:
+            mod_specs = find_pkg( f"_gclean_{iclean_backend}" )
+
+        if mod_specs:
+            self._gclean_module = load_pkg(mod_specs[0])
+        else:
+            raise ImportError(f"Could not locate {iclean_backend} kind of iclean backend")
+
+        self._args = {{forwDict}}
+        self._gclean = self._gclean_module.gclean( **self._args )
+        self._gclean_paths = self._gclean.image_products( )
+        #self._residual_path = self._residual_path(self._clean['gclean'],imid)
+        #self._mask_path = self._mask_path(self._clean['gclean'],imid)
+
+        self._ui = InteractiveCleanUI(self._gclean, self._args)
+
+
+    def __call__( self ):
+        '''Display GUI and process events until the user stops the application.
+
+        Example:
+            Create ``iclean`` object and display::
+
+                print( "Result: %s" %
+                       iclean( vis='refim_point_withline.ms', imagename='test', imsize=512,
+                               cell='12.0arcsec', specmode='cube',
+                               interpolation='nearest', ... )( ) )
+        '''
+        context = exe.Context( exe.Mode.SYNC )
+        exec_task = self._ui( exe.Setting.CLI, context, "interactive-clean" )
+        return context.execute( exec_task, "interactive-clean" )