casaconfig 0.0.84__tar.gz → 0.0.86__tar.gz

{casaconfig-0.0.84/casaconfig.egg-info → casaconfig-0.0.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: casaconfig
-Version: 0.0.84
+Version: 0.0.86
 Summary: CASA Operational Configuration Package
 Home-page: https://github.com/casangi/casaconfig
 Author: National Radio Astronomy Observatory

{casaconfig-0.0.84 → casaconfig-0.0.86}/casaconfig/__init__.py

@@ -12,3 +12,4 @@ from .private.update_all import update_all
 from .private.set_casacore_path import set_casacore_path
 from .private.get_config import get_config
 from .private.get_data_info import get_data_info
+from .private.CasaconfigErrors import *

casaconfig-0.0.86/casaconfig/__main__.py

@@ -0,0 +1,143 @@
+import sys
+import os
+from casaconfig.private.get_argparser import get_argparser
+
+parser = get_argparser(add_help=True)
+
+# get_argparser supplies configfile, noconfig, nositeconfig
+# add measurespath, pull-data, data-update, measures-update, update-all, reference-testing, current-data
+
+parser.prog = "casaconfig"
+
+# measurespath will default to the value in config if not set here
+parser.add_argument( "--measurespath", dest='measurespath', default=None,
+                     help="location of casarundata")
+
+parser.add_argument( "--pull-data", dest='pulldata', action='store_const', const=True, default=False,
+                     help="invoke pull_data() to populate measurespath with latest casarundata")
+parser.add_argument( "--data-update", dest='dataupdate', action='store_const', const=True, default=False,
+                     help="invoke data_update() to update measurespath to the latest casarundata")
+parser.add_argument( "--measures-update", dest='measuresupdate', action='store_const', const=True, default=False,
+                     help="invoke measures_update() to update measurespath to the latest measures data")
+parser.add_argument( "--update-all", dest='updateall', action='store_const', const=True, default=False,
+                     help="invoke update_all() to populate (update) measurespath with the latest casarundata and measures data")
+parser.add_argument( "--reference-testing", action='store_const', const=True, dest='referencetesting', default=False,
+                     help="set measurespath to the casarundata when this version was produced, used for testing purposes")
+parser.add_argument( "--current-data", dest='currentdata', action='store_const', const=True, default=False,
+                     help="print out a summary of the current casarundata and measures data installed in measurespath and then exit")
+parser.add_argument( "--summary", dest='summary', action='store_const', const=True, default=False,
+                     help="print out a summary of casaconfig data handling and the exit")
+parser.add_argument("--force", dest='force', action='store_const', const=True, default=False,
+                    help="force an update using the force=True option to update_all, data_update, and measures_update")
+
+# initialize the configuration to be used
+flags,args = parser.parse_known_args(sys.argv)
+from casaconfig import config
+
+# import the casaconfig module
+import casaconfig
+
+# make sure measurespath reflects any command line value
+if flags.measurespath is None:
+    flags.measurespath = config.measurespath
+else:
+    config.measurespath = flags.measurespath
+
+# watch for measurespath of None, that likely means that casasiteconfig.py is in use and this has not been set. It can't be used then.
+try:
+    if flags.measurespath is None:
+        print("measurespath has been set to None in the user or site config file.")
+        print("Either provide a measurespath on the casaconfig command line or edit the user or site config file to set measurespath to a location.")
+        sys.exit(1)
+
+    # do any expanduser and abspath - this is what should be used
+    measurespath = os.path.abspath(os.path.expanduser(flags.measurespath))
+
+    if flags.currentdata:
+        if not os.path.exists(measurespath) or not os.path.isdir(measurespath):
+            print("No data installed at %s. The measurespath does not exist or is not a directory." % measurespath)
+        else:
+            print("current data installed at %s" % measurespath)
+            dataInfo = casaconfig.get_data_info(measurespath)
+        
+            # casarundata
+            casarunInfo = dataInfo['casarundata']
+            if casarunInfo is None or casarunInfo['version'] == "invalid":
+                print("No casarundata found (missing readme.txt and not obviously legacy casa data).")
+            if casarunInfo['version'] == "error":
+                print("Unexpected casarundata readme.txt content; casarundata should be reinstalled.")
+            elif casarunInfo['version'] == "unknown":
+                print("casarundata version is unknown (probably legacy casa data not maintained by casaconfig).")
+            else:
+                currentVersion = casarunInfo['version']
+                currentDate = casarunInfo['date']
+                print('casarundata version %s installed on %s' % (currentVersion, currentDate))
+            
+            # measures
+            measuresInfo = dataInfo['measures']
+            if measuresInfo is None or measuresInfo['version'] == "invalid":
+                print("No measures data found (missing readme.txt and not obviously legacy measures data).")
+            if measuresInfo['version'] == "error":
+                print("Unexpected measures readme.txt content; measures should be reinstalled.")
+            elif measuresInfo['version'] == "unknown":
+                print("measures version is unknown (probably legacy measures data not maintained by casaconfig).")
+            else:
+                currentVersion = measuresInfo['version']
+                currentDate = measuresInfo['date']
+                print('measures version %s installed on %s' % (currentVersion, currentDate))
+ 
+        # ignore any other arguments
+    elif flags.summary:
+        from casaconfig.private.summary import summary
+        summary(config)
+        # ignore any other arguments
+    else:
+        if flags.referencetesting:
+            print("reference testing using pull_data and 'release' version into %s" % measurespath)
+            casaconfig.pull_data(measurespath,'release')
+            # ignore all other options
+        else:
+            # watch for nothing actually set
+            if not flags.updateall and not flags.pulldata and not flags.dataupdate and not flags.measuresupdate:
+                parser.print_help()
+                sys.exit(1)
+            # the update options, update all does everything, no need to invoke anything else
+            print("Checking for updates into %s" % measurespath)
+            if flags.updateall:
+                casaconfig.update_all(measurespath,force=flags.force)
+            else:
+                # do any pull_update first
+                if flags.pulldata:
+                    casaconfig.pull_data(measurespath)
+                # then data_update, not necessary if pull_data just happened
+                if flags.dataupdate and not flags.pulldata:
+                    casaconfig.data_update(measurespath, force=flags.force)
+                # then measures_update
+                if flags.measuresupdate:
+                    casaconfig.measures_update(measurespath, force=flags.force)
+
+except casaconfig.UnsetMeasurespath as exc:
+    # UnsetMeasurespath should not happen because measurespath is checked to not be None above, but just in case
+    print(str(exc))
+    print("This exception should not happen, check the previous messages for additional information and try a different path")
+    sys.exit(1)
+
+except casaconfig.BadReadme as exc:
+    print(str(exc))
+    sys.exit(1)
+
+except casaconfig.RemoteError as exc:
+    print(str(exc))
+    print("This is likely due to no network connection or bad connectivity to a remote site, wait and try again")
+    sys.exit(1)
+
+except casaconfig.BadLock as exc:
+    # the output produced by the update functions is sufficient, just re-echo the exception text itself
+    print(str(exc))
+    sys.exit(1)
+
+except casaconfig.NotWritable as exc:
+    print(str(exc))
+    sys.exit(1)
+
+sys.exit(0)

casaconfig-0.0.86/casaconfig/private/CasaconfigErrors.py

@@ -0,0 +1,42 @@
+# Copyright 2024 AUI, Inc. Washington DC, USA
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+"""
+this module will be included in the api
+"""
+
+class AutoUpdatesNotAllowed(Exception):
+    """Raised when a path does not exist or is not owned by the user"""
+    pass
+
+class BadLock(Exception):
+    """Raised when the lock file is not empty and a lock attempt was made"""
+    pass
+
+class BadReadme(Exception):
+    """Raised when a readme.txt file does not contain the expected contents"""
+    pass
+
+class NoReadme(Exception):
+    """Raised when the readme.txt file is not found at path (path also may not exist)"""
+
+class RemoteError(Exception):
+    """Raised when there is an error fetching some remote content"""
+    pass
+
+class NotWritable(Exception):
+    """Raised when the path is not writable by the user"""
+
+class UnsetMeasurespath(Exception):
+    """Raised when a path argument is None"""
+    pass

{casaconfig-0.0.84 → casaconfig-0.0.86}/casaconfig/private/config_defaults_static.py

@@ -51,3 +51,6 @@ iplogfile='ipython-%s.log' % _time.strftime("%Y%m%d-%H%M%S", _time.gmtime())
 
 # include the user's local site-packages in the python path if True. May conflict with CASA modules
 user_site = False
+
+# verbosity level for casaconfig
+casaconfig_verbose = 1

{casaconfig-0.0.84 → casaconfig-0.0.86}/casaconfig/private/data_available.py

@@ -35,12 +35,19 @@ def data_available():
     Returns
        list - version names returned as list of strings
 
+    Raises
+       - casaconfig.RemoteError - Raised when there is an error fetching some remote content
+       - Exception - Unexpected exception while getting list of available casarundata versions
+
     """
 
     import html.parser
     import urllib.request
+    import urllib.error
     import ssl
     import certifi
+
+    from casaconfig import RemoteError
     
     class LinkParser(html.parser.HTMLParser):
         def reset(self):
@@ -67,10 +74,13 @@ def data_available():
 
         # return the sorted list, earliest versions are first, newest is last
         return sorted(parser.rundataList)
-    
+
+    except urllib.error.URLError as urlerr:
+        raise RemoteError("Unable to retrieve list of available casarundata versions : " + str(urlerr)) from None
+        
     except Exception as exc:
-        print("ERROR! : unexpected exception while getting list of available casarundata versions")
-        print("ERROR! : %s" % exc)
+        msg = "Unexpected exception while getting list of available casarundata versions : " + str(exc)
+        raise Exception(msg)
 
     # nothing to return if it got here, must have been an exception
     return []

{casaconfig-0.0.84 → casaconfig-0.0.86}/casaconfig/private/data_update.py

@@ -15,12 +15,14 @@
 this module will be included in the api
 """
 
-def data_update(path=None, version=None, force=False, logger=None, auto_update_rules=False):
+def data_update(path=None, version=None, force=False, logger=None, auto_update_rules=False, verbose=None):
     """
     Check for updates to the installed casarundata and install the update or change to 
     the requested version when appropriate.
 
-    If no update is necessary then this function will silently return.
+    The verbose argument controls the level of information provided when this function when the data
+    are unchanged for expected reasons. A level of 0 prints and logs nothing. A
+    value of 1 logs the information and a value of 2 logs and prints the information.
 
     The path must contain a previously installed version of casarundata.
     Use pull_data to install casarundata into a new path (empty or does not exist).
@@ -98,29 +100,45 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
        - force (bool=False) - If True, always re-download the casarundata. Default False will not download casarundata if updated within the past day unless the version parameter is specified and different from what was last downloaded.
        - logger (casatools.logsink=None) - Instance of the casalogger to use for writing messages. Default None writes messages to the terminal.
        - auto_update_rules (bool=False) - If True then the user must be the owner of path, version must be None, and force must be False.
+       - verbose (int) - Level of output, 0 is none, 1 is to logger, 2 is to logger and terminal, defaults to casaconfig_verbose in the config dictionary.
         
     Returns
        None
     
+    Raises
+       - casaconfig.AutoUpdatesNotAllowed - raised when path does not exist as a directory or is not owned by the user
+       - casaconfig.BadLock - raised when the lock file was not empty when an attempt was made to obtain the lock
+       - casaconfig.BadReadme - raised when the readme.txt file at path did not contain the expected list of installed files or was incorrectly formatted
+       - casaconfig.NoReadme - raised when the readme.txt file is not found at path (path also may not exist)
+       - casaconfig.NotWritable - raised when the user does not have permission to write to path
+       - casaconfig.RemoteError - raised by data_available when the list of available data versions could not be fetched
+       - casaconfig.UnsetMeasurespath - raised when path is None and measurespath has not been set in config.
+       - Exception - raised when there was an unexpected exception while populating path
+
     """
 
     import os
 
-    from .data_available import data_available
+    from casaconfig import data_available
+    from casaconfig import pull_data
+    from casaconfig import get_data_info
+    from casaconfig import AutoUpdatesNotAllowed, BadReadme, BadLock, NoReadme, RemoteError, UnsetMeasurespath, NotWritable
     from .print_log_messages import print_log_messages
     from .get_data_lock import get_data_lock
-    from .pull_data import pull_data
     from .do_pull_data import do_pull_data
-    from .get_data_info import get_data_info
 
     if path is None:
         from .. import config as _config
         path = _config.measurespath
 
     if path is None:
-        print_log_messages('path is None and has not been set in config.measurespath. Provide a valid path and retry.', logger, True)
+        raise UnsetMeasurespath('data_update: path is None and has not been set in config.measurespath. Provide a valid path and retry.')
         return
 
+    if verbose is None:
+        from .. import config as _config
+        verbose = _config.casaconfig_verbose
+
     # when a specific version is requested then the measures readme.txt that is part of that version
     # will get a timestamp of now so that default measures updates won't happen for a day unless the
     # force argument is used for measures_update
@@ -131,30 +149,24 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
 
     if auto_update_rules:
         if version is not None:
-            print_log_messages('auto_update_rules requires that version be None', logger, True)
+            print_log_messages('data_update: auto_update_rules requires that version be None', logger, True)
             return
         if force:
-            print_log_messages('force must be False when auto_update_rules is True', logger, True)
+            print_log_messages('data_update: force must be False when auto_update_rules is True', logger, True)
             return
         if (not os.path.isdir(path)) or (os.stat(path).st_uid != os.getuid()):
-            msgs = []
-            msgs.append("Warning: path must exist as a directory and it must be owned by the user, path = %s" % path)
-            msgs.append("Warning: no data updates are possible on this path by this user.")
-            print_log_messages(msgs, logger, False)
-            return        
+            raise AutoUpdatesNotAllowed("data_update: path must exist as a directory and it must be owned by the user, path = %s" % path)
 
     if not os.path.exists(readme_path):
         # path must exist and it must be empty in order to continue
         if not os.path.exists(path) or (len(os.listdir(path)) > 0):
-            print_log_messages('No readme.txt file found at path. Nothing updated or checked.', logger, True);
-            return
+            raise NoReadme('data_update: no casarundata readme.txt file found at %s. Nothing updated or checked.' % path);
         # ok to install a fresh copy, use pull_data directly
-        return pull_data(path,version,force,logger)
+        return pull_data(path,version,force,logger,verbose)
 
     # path must be writable with execute bit set
     if (not os.access(path, os.W_OK | os.X_OK)) :
-        print_log_messages('No permission to write to path, cannot update : %s' % path, logger, True)
-        return
+        raise NotWritable('data_update: No permission to write to %s, cannot update.' % path)
     
     # try and digest the readme file
 
@@ -162,7 +174,8 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
     currentVersion = []
     currentDate = []
     ageRecent = False
-    
+
+    # already checked that path is OK, type is OK here, no need to trap for exceptions here
     dataReadmeInfo = get_data_info(path, logger, type='casarundata')
     
     if dataReadmeInfo is None or dataReadmeInfo['version'] == 'invalid':
@@ -188,20 +201,17 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
 
     if (len(installed_files) == 0):
         # this shouldn't happen
-        msgs = []
-        msgs.append('The readme.txt file at path did not contain the expected list of installed files')
-        msgs.append('choose a different path or empty this path and try again using pull_data')
-        print_log_messages(msgs, logger, True)
-        # no lock has been set yet, safe to simply return here
-        return
+        # no lock has been set yet, safe to raise this exception without worrying about the lock
+        raise BadReadme('data_update: the readme.txt file at path did not contain the expected list of installed files')
 
     if version is None and force is False and ageRecent:
         # if version is None, the readme is less than 1 day old  and force is False then return without checking for any newer versions
-        # normal use is silent, this line is useful during debugging
-        # print_log_messages('data_update latest version checked recently in %s, using version %s' % (path, currentVersion), logger)
+        if verbose > 0:
+            print_log_messages('data_update: version installed or checked less than 1 day ago, nothing updated or checked', logger, verbose=verbose)
         # no lock has been set yet, safe to simply return here
         return
 
+    # this may raise a RemoteError, no need to catch that here but it may need to be caught upstream
     available_data = data_available()
     requestedVersion = version
     latestVersion = False
@@ -238,19 +248,20 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
                     force = False
                 # if measuresReadmeInfo is None then that's a problem and force remains True, this also catches 'invalid' and 'unknown' measures versions, which should not happen here
             if not force:
-                # normal use is silent, this line is useful during debugging
-                # print_log_messages('data_update requested "release" version of casarundata and measures are already installed.', logger)
+                if verbose > 0:
+                    print_log_messages('data_update: requested "release" version of casarundata and measures are already installed.', logger, verbose=verbose)
                 # no lock has been set yet, safe to simply return here
                 return
         else:
             # normal usage, ok to return now
-            # normal use is silent, commented out lines are useful during debugging
             if latestVersion:
-                # print_log_messages('The latest version is already installed in %s, using version %s' % (path, currentVersion), logger)
+                if verbose > 0:
+                    print_log_messages('The latest version is already installed in %s' % path, logger, verbose=verbose)
                 # touch the dates of the readme to prevent a future check on available data for the next 24 hours
                 os.utime(readme_path)
-             #else:
-                # print_log_messages('Requested casarundata is installed in %s, using version %s' % (path, currentVersion), logger)
+            else:
+                if verbose > 0:
+                    print_log_messages('Requested casarundata version is already installed in %s, %s' % (path, currentVersion), logger, verbose=verbose)
                 
             # no lock has been set yet, safe to simply return here
             return
@@ -258,19 +269,12 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
     # an update appears necessary
 
     lock_fd = None
+    clean_lock = True   # set to False if the contents are actively being update and the lock file should not be cleaned on exception
     try:
         print_log_messages('data_update using version %s, acquiring the lock ... ' % requestedVersion, logger)
 
         lock_fd = get_data_lock(path, 'data_update')
-        # if lock_fd is None it means the lock file was not empty - because we know that path exists at this point
-        if lock_fd is None:
-            msgs = []
-            msgs.append('The lock file at %s is not empty.' % path)
-            msgs.append('A previous attempt to update path may have failed or exited prematurely.')
-            msgs.append('Remove the lock file and set force to True with the desired version (default to most recent).')
-            msgs.append('It may be best to completely repopulate path using pull_data and measures_update.')
-            print_log_messages(msgs, logger, True)
-            return
+        # the BadLock exception that may happen here is caught below
 
         do_update = True
         # it's possible that another process had path locked and updated the readme with new information, re-read it
@@ -290,58 +294,71 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
                             do_update = False
                     # if measuresReadmeInfo is None there was a problem which requires a full update so do_update remains True
                     if not do_update:
+                        # always verbose here because the lock file is in use
                         print_log_messages('data update requested "release" version of casarundata and measures are already installed.', logger)
                 else:
                     # nothing to do here, already at the expected version and an update is not being forced
                     if latestVersion:
+                        # always verbose here because the lock file is in use
                         print_log_messages('The latest version is already installed, using version %s' % currentVersion, logger)
                         # touch the dates of the readme to prevent a future check on available data for the next 24 hours
                         os.utime(readme_path)
                     else:
+                        # always verbose here because the lock file is in use
                         print_log_messages('requested version is already installed.', logger)
                     do_update = False
                     
             if do_update:
                 # update is still on, check the manifest
                 if len(installed_files) == 0:
-                    # this shouldn't happen, do not do an update
-                    do_update = False
-                    msgs = []
-                    msgs.append('The readme.txt file read at path did not contain the expected list of installed files')
-                    msgs.append('This should not happen unless multiple sessions are trying to update data at the same time and one experienced problems or was done out of sequence')
-                    msgs.append('Check for other updates in process or choose a different path or clear out this path and try again using pull_data or update_all')
-                    print_log_messages(msgs, logger, True)
+                    # this shouldn't happen, do not do an update, raise the BadReadme exception, caught below and the lock cleaned up then
+                    raise BadReadme('data_update: the readme.txt file at path did not contain the expected list of installed files')
         else:
-            # this shouldn't happen, do not do an update
-            do_update = False
-            msgs = []
-            msgs.append('Unexpected problem reading readme.txt file during data_update, can not safely update to the requested version')
-            msgs.append('This should not happen unless multiple sessions are trying to update at the same time and one experienced problems or was done out of sequence')
-            msgs.append('Check for other updates in process or choose a different path or clear out this path and try again using pull_data or update_all')
-            print_log_messages(msgs, logger, True)
+            # this shouldn't happen
+            raise BadReadme('data_update: unexpected problem reading readme.txt file during data update, can not safely update to the requested version')
 
         if do_update:
+            # do not clean the lock file contents at this point unless do_pull_data returns normally
+            clean_lock = False
             do_pull_data(path, requestedVersion, installed_files, currentVersion, currentDate, logger)
+            clean_lock = True
             if namedVersion:
                 # a specific version has been requested, set the times on the measures readme.txt to now to avoid
                 # a default update of the measures data without using the force argument
                 measuresReadmePath = os.path.join(path,'geodetic/readme.txt')
                 os.utime(measuresReadmePath)
 
-        # truncate the lock file
-        lock_fd.truncate(0)
+    except BadLock as exc:
+        # the path is known to exist so this means that the lock file was not empty and it's not locked
+        msgs = str(exc)
+        msgs.append('data_update: the lock file at %s is not empty.' % path)
+        msgs.append('A previous attempt to update path may have failed or exited prematurely.')
+        msgs.append('Remove the lock file and set force to True with the desired version (default to most recent).')
+        msgs.append('It may be best to completely re-populate path using pull_data and measures_update.')
+        print_log_messages(msgs, logger, True)
+        # reraise this
+        raise
+
+    except BadReadme as exc:
+        # something is wrong in the readme after an update was triggered, this shouldn't happen, print more context reraise this
+        msgs = str(exc)
+        msgs.append('This should not happen unless multiple sessions are trying to update data at the same time and one experienced problems or was done out of sequence')
+        msgs.append('Check for other updates in progress or choose a different path or clear out this path and try again using pull_data or update_all')
+        print_log_messages(msgs, logger, True)
+        raise
 
     except Exception as exc:
         msgs = []
         msgs.append('ERROR! : Unexpected exception while populating casarundata version %s to %s' % (requestedVersion, path))
         msgs.append('ERROR! : %s' % exc)
         print_log_messages(msgs, logger, True)
-        # leave the contents of the lock file as is to aid in debugging
-        # import traceback
-        # traceback.print_exc()
-
-    # if the lock file is not closed, do that now to release the lock
-    if lock_fd is not None and not lock_fd.closed:
-        lock_fd.close()
+        raise
+
+    finally:
+        # make sure the lock file is closed and also clean the lock file if safe to do so, this is always executed
+        if lock_fd is not None and not lock_fd.closed:
+            if clean_lock:
+                lock_fd.truncate(0)
+            lock_fd.close()
     
     return

{casaconfig-0.0.84 → casaconfig-0.0.86}/casaconfig/private/do_auto_updates.py

@@ -15,7 +15,7 @@
 this module will be included in the api
 """
 
-def do_auto_updates(configDict, logger=None):
+def do_auto_updates(configDict, logger=None, verbose=None):
     """
     Use measurespath, data_auto_update, and measures_auto_update from configDict to
     do any auto updates as necessary.
@@ -33,41 +33,45 @@ def do_auto_updates(configDict, logger=None):
     See the documentation for data_update and measures_update for additional details
     about the auto update rules.
 
+    The verbose argument controls the level of information provided when this function when the data
+    are unchanged for expected reasons. A level of 0 prints and logs nothing. A
+    value of 1 logs the information and a value of 2 logs and prints the information.
+
+    See data_update and measures_update for additional details about exceptions
+
     Paramters
        - configDict (dict) - A config dictionary previously set. 
        - logger (casatools.logsink=None) - Instance of the casalogger to use for writing messages. Default None writes messages to the terminal.
+       - verbose (int) - Level of output, 0 is none, 1 is to logger, 2 is to logger and terminal, defaults to casaconfig_verbose in the config dictionary.
 
     Returns
        None
 
+    Raises
+       - casaconfig.UnsetMeasurespath - raised when measurespath is None in config
+
     """
 
     from .print_log_messages import print_log_messages
     from .data_update import data_update
     from .measures_update import measures_update
 
+    from casaconfig import UnsetMeasurespath
+
     if configDict.measurespath is None:
         # continue, because things still might work if there are measures in datapath
-        msgs = []
-        msgs.append('measurespath is None in config')
-        msgs.append('set measurespath in your config file at ~/.casa/config.py')
-        msgs.append('or ask the site manager to set that in a casasiteconfig.py')
-        msgs.append('visit https://casadocs.readthedocs.io/en/stable/notebooks/external-data.html for more information')
-
-        if (configDict.measures_auto_update or configDict.data_auto_update):
-            msgs.append('Auto updates of measures path are not possible because measurespath is not set, skipping auto updates')
-
-        print_log_messages(msgs, logger, True)
+        raise UnsetMeasurespath('do_auto_updates: measurespath is None in configDict. Provide a valid path and retry.')
 
-        return
+    if verbose is None:
+        verbose = configDict.casaconfig_verbose
 
     if (configDict.measures_auto_update or configDict.data_auto_update):
         if (configDict.data_auto_update and (not configDict.measures_auto_update)):
             print_log_messages('measures_auto_update must be True when data_auto_update is True, skipping auto updates', logger, True)
         else:
             if configDict.data_auto_update:
-                data_update(configDict.measurespath, logger=logger, auto_update_rules=True)
+                data_update(configDict.measurespath, logger=logger, auto_update_rules=True, verbose=verbose)
             if configDict.data_auto_update or configDict.measures_auto_update:
-                measures_update(configDict.measurespath, logger=logger, auto_update_rules=True)
+                measures_update(configDict.measurespath, logger=logger, auto_update_rules=True, verbose=verbose)
 
     return

{casaconfig-0.0.84 → casaconfig-0.0.86}/casaconfig/private/get_config.py

@@ -23,10 +23,10 @@ def get_config( default=False ):
     The default values (returned when default is True) are the configuration values after all config files have been evaluated but before the path values have been expanded using os.path.expanduser and os.path.abspath. Modules that use the command line to change config values may also not update the default values. User actions in a CASA session will also typically not change the default values.
 
     Parameters
-       default (bool=False) - If True, return the default values.
+       - default (bool=False) - If True, return the default values.
 
     Returns
-       list[str] - list of configuration strings
+       - list[str] - list of configuration strings
     """
 
     from .. import config as _config

{casaconfig-0.0.84 → casaconfig-0.0.86}/casaconfig/private/get_data_info.py

@@ -76,10 +76,14 @@ def get_data_info(path=None, logger=None, type=None):
        - type (str) - the specific type of data info to return (None, 'casarundata', 'measures', 'release'; None returns a dictionary of all types)
     
     Returns
-       dict - a dictionary by type, 'casarundata', 'measures', 'release' where each type is a dictionary containing 'version' and 'date'. A return value of None indicates path is unset. A value of None for that type means no information could be found about that type. If a specific type is requested then only the dictionary for that type is returned (or None if that type can not be found).
+       - a dictionary by type, 'casarundata', 'measures', 'release' where each type is a dictionary containing 'version' and 'date'. A return value of None indicates path is unset. A value of None for that type means no information could be found about that type. If a specific type is requested then only the dictionary for that type is returned (or None if that type can not be found).
+
+    Raises
+       - casaconfig.UnsetMeasurespath - path is None and has not been set in config
+       - ValueError - raised when type has an invalid value
+
     """
 
-    # when None is returned, path wasn't set
     result = None
 
     import os
@@ -87,6 +91,9 @@ def get_data_info(path=None, logger=None, type=None):
     import importlib.resources
     from .print_log_messages import print_log_messages
     from .read_readme import read_readme
+    
+    from casaconfig import UnsetMeasurespath
+
 
     currentTime = time.time()
     secondsPerDay = 24. * 60. * 60.
@@ -96,8 +103,7 @@ def get_data_info(path=None, logger=None, type=None):
         path = _config.measurespath
 
     if path is None:
-        print_log_messages('path is None and has not been set in config.measurespath. Provide a valid path and retry.', logger, True)
-        return None
+        raise UnsetMeasurespath('get_data_info: path is None and has not been set in config.measurespath. Provide a valid path and retry.')
     
     path = os.path.abspath(os.path.expanduser(path))