cubevis 0.5.2__py3-none-any.whl

cubevis/utils/_conversion.py

@@ -0,0 +1,93 @@
+########################################################################
+#
+# Copyright (C) 2021,2023
+# 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
+#
+########################################################################
+'''Contains for conversion of data passed between Python and JavaScript
+via websockets'''
+
+import json
+import numpy as np
+from bokeh.util.serialization import transform_array
+from bokeh.core.serialization import Serializer, Deserializer
+from bokeh.core.json_encoder import serialize_json
+from ._static import static_vars
+
+def strip_arrays( val ):
+    '''convert all numpy arrays contained within val to lists
+    '''
+    if isinstance( val, dict ):
+        result = { }
+        for k, v in val.items( ):
+            result[k] = strip_arrays(v)
+        return result
+    if isinstance( val, np.ndarray ):
+        return val.tolist( )
+    if isinstance( val, range ):
+        return list(val)
+    return val
+
+@static_vars( encoder=Serializer(deferred=False) )
+def serialize( val ):
+    '''convert python values to a string that can be sent via websockets
+    '''
+    return serialize_json(serialize.encoder.serialize(val))
+
+@static_vars( decoder=Deserializer( ) )
+def deserialize( val ):
+    '''convert an encoded value received from websockets
+    '''
+    value = json.loads(val)
+    return deserialize.decoder.deserialize(value)
+
+def pack_arrays( val ):
+    """Convert `numpy` N dimensional arrays stored within a dictionary to
+    a format that can be converted into the multi-dimensional arrays that
+    are usable for Bokeh data.
+
+    Parameters
+    ----------
+    val: value
+
+    Returns
+    -------
+    value
+        return value is identical to `val` parameter except that any
+        N dimensional `numpy` arrays are converted to Bokeh compatible
+        format
+    """
+    if isinstance( val, dict ):
+        result = { }
+        for k, v in val.items( ):
+            result[k] = pack_arrays(v)
+        return result
+    if isinstance( val, np.ndarray ):
+        if isinstance(val, np.ma.MaskedArray):
+            return transform_array(val.filled(0))
+        else:
+            return transform_array(val)
+    if isinstance( val, range ):
+        return list(val)
+    return val

cubevis/utils/_copydoc.py

@@ -0,0 +1,55 @@
+########################################################################
+#
+# Copyright (C) 2024
+# 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
+#
+########################################################################
+'''Reuse doc string'''
+import os
+
+#--------------------------------------------------
+# ParamSpec is available with Python >= 3.10
+#--------------------------------------------------
+#from typing import Callable, TypeVar, ParamSpec
+#
+#P = ParamSpec("P")
+#T = TypeVar("T")
+#
+#def copydoc(src: Callable[P, T]):
+#    """Copy documentation from src"""
+#
+#    def decorator(dest: Callable) -> Callable[P, T]:
+#        dest.__doc__ = src.__doc__
+#        return dest
+#
+#    return decorator
+
+def copydoc(src):
+    """Copy documentation from src"""
+
+    def decorator(dest):
+        dest.__doc__ = src.__doc__
+        return dest
+
+    return decorator

cubevis/utils/_docenum.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+class DocEnum(Enum):
+    '''Allows for documenting individual enum values::
+
+           In [6]: class MaskMode(DocEnum):
+           ...:     'Different masking modes available in addition to a user supplied mask'
+           ...:     PB = 1, 'primary beam mask'
+           ...:     AUTOMT = 2, 'multi-threshold auto masking'
+           ...:
+
+           In [7]: MaskMode.PB?
+           Type:            MaskMode
+           String form:     MaskMode.PB
+           Docstring:       primary beam mask
+           Class docstring: Different masking modes available in addition to a user supplied mask
+
+           In [8]:
+    '''
+    def __new__(cls, value, doc=None):
+        self = object.__new__(cls)  # calling super().__new__(value) here would fail
+        self._value_ = value
+        if doc is not None:
+            self.__doc__ = doc
+        return self

cubevis/utils/_import_protected_module.py

@@ -0,0 +1,35 @@
+import inspect
+import importlib
+import sys
+import types
+
+def ImportProtectedModule( name, file_mapping ):
+
+    class module_import(types.ModuleType):
+        """Import objects, functions and classes for export while avoiding requiring user to
+           provide the sub-package name for the file contining the imported object, for example
+           allowing:
+                         from cubevis.apps import iclean
+
+           instead of:
+                         from cubevis.app._interactive_clean import iclean
+
+           while also not importing '_interactive_clean' (inside of __init__.py) regardless of
+           whether the user actually import 'iclean' or not. This is done to allow for some
+           dependencies to not be available but for the imports to still work as long as
+           the dependencies which are needed for the imported classes are available.
+        """
+
+        _module = name
+        _mapping = file_mapping
+
+        def __getattr__(self, name):
+            if name in self._mapping:
+                m = importlib.import_module(self._mapping[name], self._module)  # import submodule
+                o = getattr(m, name)                                            # find the required member
+                setattr(sys.modules[self._module], name, o)                     # bind it into the package
+                return o
+            else:
+                raise AttributeError(f'module {__name__} has no attribute {name}')
+
+    return module_import

cubevis/utils/_logging.py

@@ -0,0 +1,85 @@
+""" Use the python logging interface for cubevis logs.
+If casalog is available, then send log messages to it.
+Otherwise, use the base python logging mechanisms.
+"""
+import logging
+
+try:
+	from casatasks import casalog
+	__casalog_avail = True
+except ImportError:
+	__casalog_avail = False
+
+class _Logging:
+	# singleton instance
+	logger = None
+	log_handler = None
+
+class CasalogHandler(logging.Handler):
+	""" Logs to casalog, as appropriate """
+	# map from python logging levels to casalog priorities
+	level_to_priority = {
+		"DEBUG": "DEBUG",
+		"INFO": "INFO",
+		"WARNING": "WARN",
+		"ERROR": "SEVERE",
+		"CRITICAL": "SEVERE"
+	}
+
+	def _level_to_levelname(self, level):
+		if (level >= 50):
+			return "CRITICAL"
+		if (level >= 40):
+			return "ERROR"
+		if (level >= 30):
+			return "WARNING"
+		if (level >= 20):
+			return "INFO"
+		return "DEBUG"
+
+	def setLevel(self, level_or_levelname):
+		super().setLevel(level_or_levelname)
+		if type(level_or_levelname) != str:
+			levelname = self._level_to_levelname(level_or_levelname)
+		else:
+			levelname = level_or_levelname
+		casalog.filter(CasalogHandler.level_to_priority[levelname])
+
+	def emit(self, record):
+		# promote log level for casalog
+		levelname = self._level_to_levelname(_Logging.logger.getEffectiveLevel())
+		if levelname == "DEBUG":
+			casalog.filter(CasalogHandler.level_to_priority["DEBUG"])
+
+		# get log properties
+		origin = (record.filename) if (record.filename != None) else ("")
+		casalog.origin(origin)
+		priority = CasalogHandler.level_to_priority[record.levelname]
+		self.format(record) # populates record.message
+
+		# emit the log
+		casalog.post(message=record.message, priority=priority, origin=record.funcName)
+
+class CasalogLogger(logging.getLoggerClass()):
+	def setLevel(self, level):
+		super().setLevel(level)
+		_Logging.log_handler.setLevel(level)
+
+def get_logger():
+	""" Returns the singleton logger instance. """
+	if _Logging.logger != None:
+		return _Logging.logger
+
+	if __casalog_avail:
+		_Logging.log_handler = CasalogHandler()
+
+		curr_logger_class = logging.getLoggerClass()
+		logging.setLoggerClass(CasalogLogger)
+		_Logging.logger = logging.getLogger(__name__)
+		logging.setLoggerClass(curr_logger_class)
+
+		_Logging.logger.addHandler(_Logging.log_handler)
+		_Logging.logger.propagate = False
+	else:
+		_Logging.logger = logging.getLogger(__name__)
+	return _Logging.logger

cubevis/utils/_pkgs.py

@@ -0,0 +1,77 @@
+import os
+import sys
+import importlib.util
+from os.path import join, exists, realpath
+
+def find_pkg( name, extra_dirs=[] ):
+    """
+    Returns list of paths which contain the ``name`` pkg. It is assumed that the
+    ``name`` will be the name of a directory (containing the package) or that
+    ``name.py(c)`` will be a file that exists. This does not attempt to import the
+    package.
+
+    Parameters
+    ----------
+    name: string
+        the name of the package in python "dot" notation to be searched for
+    extra_dirs: list of strings
+        directories to be searched in addition to those included in ``sys.path``
+
+    Returns
+    -------
+    list of import specifications
+        specifications of ``name`` found by search ``sys.path`` and ``extra_dirs``
+    """
+    result = [ ]
+    filename = (name.split('.'))
+    for dir in sys.path[:] + extra_dirs:
+        path = join( dir, *filename )
+        if exists(path):
+            spec = importlib.util.spec_from_file_location(name,path)
+            if spec:
+                result.append(spec)
+        else:
+            path = f"{path}.py"
+            if exists(path):
+                spec = importlib.util.spec_from_file_location(name,path)
+                if spec:
+                    result.append(spec)
+            else:
+                path = f"{path}c"
+                if exists(path):
+                    spec = importlib.util.spec_from_file_location(name,path)
+                    if spec:
+                        result.append(spec)
+    return result
+
+def load_pkg( spec ):
+    """
+    Loads and returns the module specified by ``spec`` (e.g. as returned from ``find_pkg``)
+    If ``spec.name`` does not already exist in ``sys.modules``, it is added.
+
+    Parameters
+    ----------
+    spec: ModuleSpec
+        the module to be loaded
+
+    Returns
+    -------
+    module
+        the loaded module
+    """
+
+    import _frozen_importlib
+    if not isinstance(spec,_frozen_importlib.ModuleSpec):
+        raise ImportError(f"Expected ModuleSpec instead of {type(spec)}")
+
+    pkg = importlib.util.module_from_spec(spec)
+
+    try:
+        spec.loader.exec_module(pkg)
+    except:
+        raise ImportError(f"Could not load {spec.origin}")
+
+    if spec.name not in sys.modules:
+        sys.modules[spec.name] = pkg
+
+    return pkg

cubevis/utils/_regions.py

@@ -0,0 +1,40 @@
+
+from itertools import product
+from matplotlib.path import Path
+from math import floor,ceil
+
+def polygon_indexes( xs, ys, shape ):
+    '''
+    Returns indexes for a 2D array of the given ``shape`` which
+    lie within the polygon specified by ``xs`` and ``ys``.
+
+    Parameters
+    ----------
+    xs: list of numbers
+        the X coordinates for the vertices of the polygon
+    ys: list of numbers
+        the Y coordinates for the vertices of the polygon
+    shape: ( int, int )
+        the shape of the plane in which the polygon is found
+
+    Returns
+    -------
+    generator of tuples:
+        the stream of tuples that is returned will be the indexes
+        of the elements which lie within the polygon
+    '''
+    assert len(shape) == 2, 'contains only works for 2D shapes, so "shape" should have length equal to two'
+    assert len(xs) == len(ys), 'to specify a polygon the number of X values must equal the number of Y values'
+
+    if len(xs) == 4 and len(ys) == 4 :
+        uniqx = sorted(set(xs))
+        uniqy = sorted(set(ys))
+        if len(uniqx) == 2 and len(uniqy) == 2:
+            ### we have a proper box, the Path.contains_point implementation seems to
+            ### err slightly with very small regions...
+            return product(range(max(floor(uniqx[0]),0),min(ceil(uniqx[1]),shape[0]-1)),range(max(floor(uniqy[0]),0),min(ceil(uniqy[1]),shape[1]-1)))
+
+    path = Path(list(zip(xs,ys)))
+    xmin, xmax = max([0,min(xs)-1]), max(xs)+1
+    ymin, ymax = max([0,min(ys)-1]), max(ys)+1
+    return filter( path.contains_point, product(range(max(floor(xmin),0),min(ceil(xmax),shape[0]-1)), range(max(floor(ymin),0),min(ceil(ymax),shape[1]-1))) )

cubevis/utils/_static.py

@@ -0,0 +1,66 @@
+########################################################################
+#
+# Copyright (C) 2021,2023
+# 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
+#
+########################################################################
+'''Contains functions for attaching static value as attributes of functions'''
+
+def static_vars(**kwargs):
+    '''Initialize static function variables to for use within a function.
+
+    This function is used as a decorator which allows for the initialization of
+    static local variables for use within a function. It is used like:
+
+            @static_vars(counter=0)
+            def foo():
+                foo.counter += 1
+                print "Counter is %d" % foo.counter
+
+    This is used from:
+    https://stackoverflow.com/questions/279561/what-is-the-python-equivalent-of-static-variables-inside-a-function?rq=1
+
+    Parameters
+    ----------
+    Initialized static local variables.
+    '''
+
+    def decorate(func):
+        for k, v in kwargs.items():
+            setattr(func, k, v)
+        return func
+
+    return decorate
+
+
+def static_dir(func):
+    '''return a list of static variables associated with ``func``
+
+    Parameters
+    ----------
+    func: function
+        function with static variables
+    '''
+    return [a for a in dir(func) if a[0] != '_']
+

cubevis/utils/_tiles.py

@@ -0,0 +1,167 @@
+########################################################################
+#
+# Copyright (C) 2023
+# 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
+#
+########################################################################
+'''tiling utilities'''
+
+from math import ceil, log
+
+class TMSTiles(object):
+    ###
+    ### This class is based upon https://github.com/OSGeo/gdal/blob/master/swig/python/gdal-utils/osgeo_utils/gdal2tiles.py
+    ### written by:       Klokan Petr Pridal (klokan at klokan dot cz)
+    ###                   Even Rouault (even dot rouault at spatialys.com)
+    ###                   Idan Miara (idan@miara.com)
+    ### It is a small subset of the original source code, and it is highly modified to only
+    ### handle raster profile tiling. The original source code has many useful details and
+    ### supports mercator and geodetic data. The subset of gdal2tiles.py used here is less
+    ### than 3% of the original file (42 lines out of 1697). While this is not considered
+    ### a substantial portion, it was invaluable for understanding the TMS tile layout.
+    ###
+    def __init__( self, dimension, title='' ):
+        '''
+        Construct a tiling object which will provide the coordinates of tiles, the size to
+        be read, the size of the scaled tile and the write offset within the :code:`tile_size`
+        output tile.
+
+        Parameters
+        ----------
+        dimension: list or tuple
+            should contain at least two elements (X,Y)
+        '''
+
+        def calculate_indexes( tz, result={ } ):
+
+            ti = 0
+            tile_details = []
+            tminx, tminy, tmaxx, tmaxy = self.tminmax[tz]
+
+            for ty in range(tmaxy, tminy - 1, -1):
+                for tx in range(tminx, tmaxx + 1):
+                    ti += 1
+                    ytile = ty
+                    index = ( tz, tx, ty )
+
+                    tsize = int(self.tsize[tz])   # tile_size in raster coordinates for actual zoom
+                    xsize = self.__dimension[0]
+                    ysize = self.__dimension[1]
+                    querysize = self.__tile_size
+
+                    rx = tx * tsize
+                    rxsize = 0
+                    if tx == tmaxx:
+                        rxsize = xsize % tsize
+                    if rxsize == 0:
+                        rxsize = tsize
+
+                    ry = ty * tsize
+                    rysize = 0
+                    if ty == tmaxy:
+                        rysize = ysize % tsize
+                    if rysize == 0:
+                        rysize = tsize
+
+                    wx, wy = 0, 0
+                    wxsize = int(rxsize / float(tsize) * self.__tile_size)
+                    wysize = int(rysize / float(tsize) * self.__tile_size)
+
+                    ry = ysize - (ty * tsize) - rysize
+                    if wysize != self.__tile_size:
+                        wy = self.__tile_size - wysize
+
+                    result[index] = dict( src=dict( idx=(rx, ry), dim=(rxsize, rysize),
+                                                    t=(( 0, 0 if rysize == tsize else tsize - rysize ), tsize ) ),
+                                          dst=dict( idx=(wx, wy), dim=(wxsize, wysize) ) )
+            return result
+
+        self.__title = title
+        self.__tile_size = 256
+        self.__dimension = dimension
+        self.__zoom = (0, max( 0, int( max( ceil(log(dimension[0] / float(self.__tile_size), 2 )),
+                                            ceil( log(dimension[1] / float(self.__tile_size), 2 )) ) ) ) )
+        native_zoom = self.__zoom[1]
+
+        # Generate table with min max tile coordinates for all zoomlevels
+        self.tminmax = list(range(self.__zoom[0], self.__zoom[1] + 1))
+        self.tsize = list(range(self.__zoom[0], self.__zoom[1] + 1))
+        for tz in range(self.__zoom[0], self.__zoom[1] + 1):
+            tsize = 2.0**(native_zoom - tz) * self.__tile_size
+            tminx, tminy = 0, 0
+            tmaxx = int(ceil(dimension[0] / tsize)) - 1
+            tmaxy = int(ceil(dimension[1] / tsize)) - 1
+            self.tsize[tz] = ceil(tsize)
+            self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)
+
+        self.__units_per_pixel = { }
+        for z in range(self.__zoom[0], self.__zoom[1] + 1):
+            self.__units_per_pixel[z] = 2**(self.__zoom[1] - z)
+
+        self.__tile_details = { }
+        for z in range(self.__zoom[0], self.__zoom[1] + 1):
+            calculate_indexes( z, self.__tile_details )
+
+    def profile( self ):
+        return "raster"
+
+    def dim( self ):
+        return self.__dimension
+
+    def tile_size( self ):
+        return self.__tile_size
+
+    def tile( self, z, x=None, y=None ):
+        try:
+            if (type(z) == tuple or type(z) == list) and len(z) == 3 and x is None and y is None:
+                return self.__tile_details[ (int(z[0]),int(z[1]),int(z[2])) ]
+            elif type(x) is not None and type(y) is not None:
+                return self.__tile_details[ (int(z),int(x),int(y)) ]
+            else:
+                raise RuntimeError( 'tile requires 3 integer parameters or 1 tuple[3] parameter' )
+        except KeyError:
+            return None
+
+    def zoom_levels( self, reverse=False ):
+        return sorted( list(self.__units_per_pixel.keys( )), reverse=reverse )
+
+    def units_per_pixel( self, zoom_level ):
+        if zoom_level not in self.__units_per_pixel:
+            raise RuntimeError(f'''{zoom_level} is not an existing zoom level''')
+        return self.__units_per_pixel[zoom_level]
+
+    def __str__( self ):
+        return f'''<?xml version="1.0" encoding="utf-8"?>
+    <TileMap version="1.0.0" tilemapservice="http://tms.osgeo.org/1.0.0">
+      <Title>{self.__title}</Title>
+      <Abstract></Abstract>
+      <SRS></SRS>
+      <BoundingBox minx="0.0000" miny="0.0000" maxx="{self.__dimension[0]}.0000" maxy="{self.__dimension[1]}.0000"/>
+      <Origin x="0.0000" y="0.0000"/>
+      <TileFormat width="256" height="256" mime-type="image/png" extension="png"/>
+      <TileSets profile="raster">''' + "\n" + '\n'.join( map( lambda z: f'''        <TileSet href="{z}" units-per-pixel="{self.units_per_pixel(z)}.0000" order="{z}"/>''',
+                                                              self.zoom_levels( ) ) ) + f'''
+      </TileSets>
+    </TileMap>
+'''