Merge pull request lammps#4514 from akohlmey/library-handle-argument-errors

Improve handling argument errors with library interface functions

Author: akohlmey

doc/src/Library_utility.rst

@@ -20,6 +20,7 @@ functions.  They do not directly call the LAMMPS library.
 - :cpp:func:`lammps_force_timeout`
 - :cpp:func:`lammps_has_error`
 - :cpp:func:`lammps_get_last_error_message`
+- :cpp:func:`lammps_set_show_error`
 - :cpp:func:`lammps_python_api_version`
 
 The :cpp:func:`lammps_free` function is a clean-up function to free
@@ -110,6 +111,11 @@ where such memory buffers were allocated that require the use of
 
 -----------------------
 
+.. doxygenfunction:: lammps_set_show_error
+   :project: progguide
+
+-----------------------
+
 .. doxygenfunction:: lammps_python_api_version
    :project: progguide
 

doc/utils/sphinx-config/false_positives.txt

@@ -736,6 +736,7 @@ dE
 De
 deallocate
 deallocated
+deallocation
 debye
 Debye
 Decius

examples/COUPLE/plugin/liblammpsplugin.c

@@ -204,6 +204,7 @@ liblammpsplugin_t *liblammpsplugin_load(const char *lib)
     ADDSYM(has_error);
     ADDSYM(get_last_error_message);
   }
+  ADDSYM(set_show_error);
 
   ADDSYM(python_api_version);
   return lmp;

examples/COUPLE/plugin/liblammpsplugin.h

@@ -109,6 +109,7 @@ struct _liblammpsplugin {
   int abiversion;
   int has_exceptions;
   void *handle;
+
 #if defined(LAMMPS_LIB_MPI)
   void *(*open)(int, char **, MPI_Comm, void **);
 #else
@@ -187,7 +188,7 @@ struct _liblammpsplugin {
  * the ifdef ensures they are compatible with rest of LAMMPS
  * caller must match to how LAMMPS library is built */
 
-#ifndef LAMMPS_BIGBIG
+#if !defined(LAMMPS_BIGBIG)
  int (*create_atoms)(void *, int, int *, int *, double *, double *, int *, int);
 #else
   int (*create_atoms)(void *, int, int64_t *, int *, double *, double *, int64_t *, int);
@@ -255,6 +256,7 @@ struct _liblammpsplugin {
 
   int (*has_error)(void *);
   int (*get_last_error_message)(void *, char *, int);
+  int (*set_show_error)(void *, const int);
 
   int (*python_api_version)();
 };

fortran/lammps.f90

@@ -248,6 +248,7 @@ MODULE LIBLAMMPS
     PROCEDURE :: force_timeout          => lmp_force_timeout
     PROCEDURE :: has_error              => lmp_has_error
     PROCEDURE :: get_last_error_message => lmp_get_last_error_message
+    PROCEDURE :: set_show_error         => lmp_set_show_error
   END TYPE lammps
 
   INTERFACE lammps
@@ -1041,6 +1042,13 @@ INTEGER(c_int) FUNCTION lammps_get_last_error_message &
       INTEGER(c_int), VALUE :: buf_size
     END FUNCTION lammps_get_last_error_message
 
+    INTEGER(c_int) FUNCTION lammps_set_show_error(handle,flag) BIND(C)
+      IMPORT :: c_ptr, c_int
+      IMPLICIT NONE
+      TYPE(c_ptr), VALUE :: handle
+      INTEGER(c_int), VALUE :: flag
+    END FUNCTION lammps_set_show_error
+
     !---------------------------------------------------------------------
     ! Utility functions imported for convenience (not in library.h)
     !---------------------------------------------------------------------
@@ -3666,6 +3674,14 @@ SUBROUTINE lmp_get_last_error_message(self, buffer, status)
     END IF
   END SUBROUTINE lmp_get_last_error_message
 
+  ! equivalent function to lammps_set_show_error
+  INTEGER FUNCTION lmp_set_show_error(self, flag)
+    CLASS(lammps), INTENT(IN) :: self
+    INTEGER, INTENT(IN) :: flag
+
+    lmp_set_show_error = lammps_set_show_error(self%handle, flag)
+  END FUNCTION lmp_set_show_error
+
   ! ----------------------------------------------------------------------
   ! functions to assign user-space pointers to LAMMPS data
   ! ----------------------------------------------------------------------

python/lammps/constants.py

@@ -50,6 +50,8 @@
 LMP_VAR_VECTOR     = 2
 LMP_VAR_STRING     = 3
 
+# default buffer size for string buffers
+LMP_BUFSIZE        = 1024
 # -------------------------------------------------------------------------
 
 def get_ctypes_int(size):

python/lammps/core.py

@@ -29,7 +29,7 @@
   LMP_TYPE_SCALAR, LMP_TYPE_VECTOR, LMP_TYPE_ARRAY, \
   LMP_SIZE_VECTOR, LMP_SIZE_ROWS, LMP_SIZE_COLS, \
   LMP_VAR_EQUAL, LMP_VAR_ATOM, LMP_VAR_VECTOR, LMP_VAR_STRING, \
-  get_ctypes_int
+  LMP_BUFSIZE, get_ctypes_int
 
 from lammps.data import NeighList
 
@@ -347,6 +347,8 @@ def __init__(self,name='',cmdargs=None,ptr=None,comm=None):
 
     self.lib.lammps_get_last_error_message.argtypes = [c_void_p, c_char_p, c_int]
     self.lib.lammps_get_last_error_message.restype = c_int
+    self.lib.lammps_set_show_error.argtypes = [c_void_p, c_int]
+    self.lib.lammps_set_show_error.restype = c_int
 
     self.lib.lammps_extract_global.argtypes = [c_void_p, c_char_p]
     self.lib.lammps_extract_global_datatype.argtypes = [c_void_p, c_char_p]
@@ -704,8 +706,8 @@ def get_os_info(self):
     :rtype:  string
     """
 
-    sb = create_string_buffer(512)
-    self.lib.lammps_get_os_info(sb,512)
+    sb = create_string_buffer(LMP_BUFSIZE)
+    self.lib.lammps_get_os_info(sb, LMP_BUFSIZE)
     return sb.value.decode()
 
   # -------------------------------------------------------------------------
@@ -734,8 +736,8 @@ def get_mpi_comm(self):
 
   @property
   def _lammps_exception(self):
-    sb = create_string_buffer(100)
-    error_type = self.lib.lammps_get_last_error_message(self.lmp, sb, 100)
+    sb = create_string_buffer(LMP_BUFSIZE)
+    error_type = self.lib.lammps_get_last_error_message(self.lmp, sb, LMP_BUFSIZE)
     error_msg = sb.value.decode().strip()
 
     if error_type == 2:
@@ -2124,6 +2126,27 @@ def is_running(self):
 
   # -------------------------------------------------------------------------
 
+  def set_show_error(self, flag):
+    """ Enable or disable direct printing of error messages in C++ code
+
+    .. versionadded:: TBD
+
+    This function allows to enable or disable printing of error message directly in
+    the C++ code.  Disabling the printing avoids printing error messages twice when
+    detecting and re-throwing them in Python code.
+
+    This is a wrapper around the :cpp:func:`lammps_set_show_error`
+    function of the library interface.
+
+    :param flag: enable (1) or disable (0) printing of error message
+    :type flag: int
+    :return: previous setting of the flag
+    :rtype: int
+    """
+    self.lib.lammps_set_show_error(self.lmp, flag)
+
+  # -------------------------------------------------------------------------
+
   def force_timeout(self):
     """ Trigger an immediate timeout, i.e. a "soft stop" of a run.
 
@@ -2300,8 +2323,9 @@ def get_gpu_device_info(self):
     :rtype:  string
     """
 
-    sb = create_string_buffer(8192)
-    self.lib.lammps_get_gpu_device_info(sb,8192)
+    BUFSIZE = 8192
+    sb = create_string_buffer(BUFSIZE)
+    self.lib.lammps_get_gpu_device_info(sb, BUFSIZE)
     return sb.value.decode()
 
   # -------------------------------------------------------------------------
@@ -2318,9 +2342,9 @@ def installed_packages(self):
     if self._installed_packages is None:
       self._installed_packages = []
       npackages = self.lib.lammps_config_package_count()
-      sb = create_string_buffer(100)
+      sb = create_string_buffer(LMP_BUFSIZE)
       for idx in range(npackages):
-        self.lib.lammps_config_package_name(idx, sb, 100)
+        self.lib.lammps_config_package_name(idx, sb, LMP_BUFSIZE)
         self._installed_packages.append(sb.value.decode())
     return self._installed_packages
 
@@ -2356,17 +2380,18 @@ def available_styles(self, category):
     :return: list of style names in given category
     :rtype:  list
     """
+    BUFSIZE = 8192
     if self._available_styles is None:
       self._available_styles = {}
 
     if category not in self._available_styles:
       self._available_styles[category] = []
       with ExceptionCheck(self):
         nstyles = self.lib.lammps_style_count(self.lmp, category.encode())
-      sb = create_string_buffer(100)
+      sb = create_string_buffer(BUFSIZE)
       for idx in range(nstyles):
         with ExceptionCheck(self):
-          self.lib.lammps_style_name(self.lmp, category.encode(), idx, sb, 100)
+          self.lib.lammps_style_name(self.lmp, category.encode(), idx, sb, BUFSIZE)
         self._available_styles[category].append(sb.value.decode())
     return self._available_styles[category]
 
@@ -2411,9 +2436,9 @@ def available_ids(self, category):
     available_ids = []
     if category in categories:
       num = self.lib.lammps_id_count(self.lmp, category.encode())
-      sb = create_string_buffer(100)
+      sb = create_string_buffer(LMP_BUFSIZE)
       for idx in range(num):
-        self.lib.lammps_id_name(self.lmp, category.encode(), idx, sb, 100)
+        self.lib.lammps_id_name(self.lmp, category.encode(), idx, sb, LMP_BUFSIZE)
         available_ids.append(sb.value.decode())
     return available_ids
 
@@ -2433,10 +2458,10 @@ def available_plugins(self, category):
 
     available_plugins = []
     num = self.lib.lammps_plugin_count(self.lmp)
-    sty = create_string_buffer(100)
-    nam = create_string_buffer(100)
+    sty = create_string_buffer(LMP_BUFSIZE)
+    nam = create_string_buffer(LMP_BUFSIZE)
     for idx in range(num):
-      self.lib.lammps_plugin_name(idx, sty, nam, 100)
+      self.lib.lammps_plugin_name(idx, sty, nam, LMP_BUFSIZE)
       available_plugins.append([sty.value.decode(), nam.value.decode()])
     return available_plugins
 

python/setup.py

@@ -44,6 +44,7 @@ def has_ext_modules(self):
 setup(
     name = "lammps",
     version = get_lammps_version(),
+    license = "GPL-2.0-only",
     author = "The LAMMPS Developers",
     author_email = "[email protected]",
     url = "https://www.lammps.org",
@@ -57,11 +58,10 @@ def has_ext_modules(self):
         "Programming Language :: Python :: 3",
         "Development Status :: 5 - Production/Stable",
         "Environment :: Console",
-        "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
         "Operating System :: OS Independent",
     ],
-    license = "GPL",
     packages = pkgs,
     package_data = pkgdata,
     distclass = bdist,
+    python_requires = '>=3.6',
 )

src/error.cpp

@@ -35,7 +35,7 @@ static std::string truncpath(const std::string &path)
 /* ---------------------------------------------------------------------- */
 
 Error::Error(LAMMPS *lmp)
-  : Pointers(lmp), numwarn(0), maxwarn(100), allwarn(0)
+  : Pointers(lmp), numwarn(0), maxwarn(100), allwarn(0), showerror(1)
 {
   last_error_message.clear();
   last_error_type = ERROR_NONE;
@@ -56,7 +56,7 @@ void Error::universe_all(const std::string &file, int line, const std::string &s
   } catch (fmt::format_error &) {
     ; // do nothing
   }
-  if (universe->me == 0) {
+  if (showerror && (universe->me == 0)) {
     if (universe->uscreen)  fputs(mesg.c_str(),universe->uscreen);
     if (universe->ulogfile) fputs(mesg.c_str(),universe->ulogfile);
   }
@@ -84,7 +84,10 @@ void Error::universe_one(const std::string &file, int line, const std::string &s
 {
   std::string mesg = fmt::format("ERROR on proc {}: {} ({}:{})\n",
                                  universe->me,str,truncpath(file),line);
-  if (universe->uscreen) fputs(mesg.c_str(),universe->uscreen);
+  if (showerror) {
+    if (universe->uscreen) fputs(mesg.c_str(),universe->uscreen);
+    if (universe->ulogfile) fputs(mesg.c_str(),universe->ulogfile);
+  }
   utils::flush_buffers(lmp);
 
   // allow commands if an exception was caught in a run
@@ -131,7 +134,7 @@ void Error::all(const std::string &file, int line, int failed, const std::string
 
   if (failed > NOLASTLINE) mesg += utils::point_to_error(input, failed);
   if (failed == ARGZERO) mesg += utils::point_to_error(input, 0);
-  if (me == 0) utils::logmesg(lmp,mesg);
+  if (showerror && (me == 0)) utils::logmesg(lmp,mesg);
   utils::flush_buffers(lmp);
 
   // allow commands if an exception was caught in a run
@@ -164,11 +167,12 @@ void Error::one(const std::string &file, int line, int failed, const std::string
   std::string mesg = fmt::format("ERROR on proc {}: {} ({}:{})\n", me, str, truncpath(file), line);
   if (failed > NOPOINTER) mesg += utils::point_to_error(input, failed);
   if (failed == ARGZERO) mesg += utils::point_to_error(input, 0);
-  utils::logmesg(lmp,mesg);
+  if (showerror) utils::logmesg(lmp,mesg);
 
-  if (universe->nworlds > 1)
-    if (universe->uscreen)
-      fputs(mesg.c_str(),universe->uscreen);
+  if (showerror && (universe->nworlds > 1)) {
+    if (universe->uscreen) fputs(mesg.c_str(),universe->uscreen);
+    if (universe->ulogfile) fputs(mesg.c_str(),universe->ulogfile);
+  }
 
   utils::flush_buffers(lmp);
   // allow commands if an exception was caught in a run
@@ -213,8 +217,7 @@ void Error::warning(const std::string &file, int line, const std::string &str)
 {
   ++numwarn;
   if ((maxwarn != 0) && ((numwarn > maxwarn) || (allwarn > maxwarn) || (maxwarn < 0))) return;
-  std::string mesg = fmt::format("WARNING: {} ({}:{})\n",
-                                 str,truncpath(file),line);
+  std::string mesg = fmt::format("WARNING: {} ({}:{})\n", str,truncpath(file),line);
   if (screen) fputs(mesg.c_str(),screen);
   if (logfile) fputs(mesg.c_str(),logfile);
 }
@@ -308,3 +311,16 @@ void Error::set_last_error(const char *msg, ErrorType type)
   last_error_message = msg;
   last_error_type = type;
 }
+
+/* ----------------------------------------------------------------------
+   enable or disable printing error messages. for use with library interface.
+   if flag = 0 only last error message and type are updated.
+   returns the previous setting.
+------------------------------------------------------------------------- */
+
+int Error::set_show_error(const int flag)
+{
+  int oldflag = showerror;
+  showerror = flag;
+  return oldflag;
+}

src/error.h

@@ -98,12 +98,13 @@ class Error : protected Pointers {
   std::string get_last_error() const;
   ErrorType get_last_error_type() const;
   void set_last_error(const char *msg, ErrorType type = ERROR_NORMAL);
+  int set_show_error(const int flag);
 
  private:
   std::string last_error_message;
   ErrorType last_error_type;
 
-  int numwarn, maxwarn, allwarn;
+  int numwarn, maxwarn, allwarn, showerror;
   // internal versions that accept explicit fmtlib arguments
   [[noreturn]] void _all(const std::string &, int, int, fmt::string_view, fmt::format_args args);
   [[noreturn]] void _one(const std::string &, int, int, fmt::string_view, fmt::format_args args);