casaconfig 0.0.83__tar.gz → 0.0.85__tar.gz

{casaconfig-0.0.83/casaconfig.egg-info → casaconfig-0.0.85}/PKG-INFO

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

{casaconfig-0.0.83 → casaconfig-0.0.85}/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.85/casaconfig/__main__.py

@@ -0,0 +1,139 @@
+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:
+            # 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.85/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.83 → casaconfig-0.0.85}/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.83 → casaconfig-0.0.85}/casaconfig/private/data_available.py

@@ -29,18 +29,25 @@ def data_available():
     changing casaconfig functions that use those tarballs). The full filename is
     the casarundata version expected in casaconfig functions.
 
-    Parameters
+    Parameters:
        None
     
-    Returns
-       list - version names returned as list of strings
+    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.83 → casaconfig-0.0.85}/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).
@@ -92,36 +94,51 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
     **Note:** the most recent casarundata may not include the most recent measures data. A data_update
     is typically followed by a measures_update.
 
-    Parameters
-       - path (str=None) - Folder path to update. Must contain a valid readme.txt. If not set then config.measurespath is used.
-       - version (str=None) - Version of casarundata to retrieve (usually in the form of casarundata-x.y.z.tar.gz, see data_available()). Default None retrieves the latest.
-       - 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.
+    Parameters:
+       path (str=None): Folder path to update. Must contain a valid readme.txt. If not set then config.measurespath is used.
+       version (str=None): Version of casarundata to retrieve (usually in the form of casarundata-x.y.z.tar.gz, see data_available()). Default None retrieves the latest.
+       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
+    Returns:
        None
     
+    Raises:
+       AutoUpdatesNotAllowed : raised when path does not exist as a directory or is not owned by the user
+       BadLock : raised when the lock file was not empty when an attempt was made to obtain the lock
+       BadReadme : raised when the readme.txt file at path did not contain the expected list of installed files or was incorrectly formatted
+       NoReadme : raised when the readme.txt file is not found at path (path also may not exist)
+       NotWritable : raised when the user does not have permission to write to path
+       RemoteError : raised by data_available when the list of available data versions could not be fetched
+       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 datetime import datetime
 
-    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
@@ -132,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
 
@@ -163,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':
@@ -180,7 +192,7 @@ def data_update(path=None, version=None, force=False, logger=None, auto_update_r
     if dataReadmeInfo['age'] is not None:
         ageRecent = dataReadmeInfo['age'] < 1.0
 
-    if currentVersion is 'unknown':
+    if currentVersion == 'unknown':
         msgs = []
         msgs.append('The data update path appears to be casarundata but no readme.txt file was found')
         msgs.append('A data update is not possible but CASA use of this data may be OK.')
@@ -189,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
@@ -239,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
@@ -259,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
@@ -291,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)
-            if namedVersion is not None:
+            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.83 → casaconfig-0.0.85}/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.
 
-    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.
+    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.
 
-    Returns
+    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:
+      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