Feat/added block support to convert module (#666)

* Fixing a character being "eaten" when the comment was made with /com,.

* Adding 'WARNING' keyword to consider 'loglevel='warning''

* Added block commands conversion capabilities (ex CMBLOCK, NBLOCK, etc).

Added function to convert strings.
Detached main converting to '_convert' which is called when you want to convert strings or files.

* Added test cases for 'convert_apdl_string' and the block commands (only nblock, eblock and cmblock, the most used)

* Small change in how data is stored.

* Fixing format.

* Fixing doc.

* Added reference to new function in documentation.

* If the input of `convert_apdl_strings` is a string, the output is a string.
Same if it is a list of strings the output is a list of strings

* Removing conversion from /COM to #.

* C*** to behave equal to /COM

* Fixed passing the arguments between `convert_apdl_string` and the FileTranslator class.

* Added switch to go into non_interactive if the output comamnd is issued.

* Added conversor for NOPR, *DO and /output.

Also I account for verify to be input in FINISH mode.

Skip mapdl.get in non_interactive mode.

Added function for run underscored_run

* Added missig `log_apdl` argument passing.

* Apply suggestions from code review - Part 1

Co-authored-by: Alex Kaszynski <[email protected]>

* Apply suggestions from code review

Co-authored-by: Alex Kaszynski <[email protected]>

* Renamed function to ``convert_apdl_block``

* Fixing style.

* Fixing wrong method order.

Co-authored-by: Alex Kaszynski <[email protected]>

Author: germa89

ansys/mapdl/core/convert.py

@@ -1,4 +1,5 @@
 import os
+from warnings import warn
 
 from ansys.mapdl.core import __version__
 from ansys.mapdl.core.misc import is_float
@@ -61,21 +62,105 @@ def convert_script(
     >>> from ansys.mapdl.core import examples
     >>> clines = pymapdl.convert_script(examples.vmfiles['vm1'], 'vm1.py')
     """
+    with open(filename_in, 'r') as fid:
+        apdl_strings = fid.readlines()
+
+    translator = _convert(apdl_strings=apdl_strings,
+                                loglevel=loglevel,
+                                auto_exit=auto_exit,
+                                line_ending=line_ending,
+                                exec_file=exec_file,
+                                macros_as_functions=macros_as_functions,
+                                use_function_names=use_function_names
+                          )
+
+    translator.save(filename_out)
+    return translator.lines
+
+
+def convert_apdl_block(apdl_strings,
+    loglevel="WARNING",
+    auto_exit=True,
+    line_ending=None,
+    exec_file=None,
+    macros_as_functions=True,
+    use_function_names=True,
+                       ):
+    """Converts an ANSYS input string to a python PyMAPDL string.
+
+    Parameters
+    ----------
+    apdl_string : str
+        APDL strings or list of strings to convert.
+
+    filename_out : str
+        Filename of the python script to write a translation to.
+
+    loglevel : str, optional
+        Logging level of the ansys object within the script.
+
+    auto_exit : bool, optional
+        Adds a line to the end of the script to exit MAPDL.  Default
+        ``True``.
+
+    line_ending : str, optional
+        When None, automatically determined by OS being used.
+
+    macros_as_functions : bool, optional
+        Attempt to convert MAPDL macros to python functions.
+
+    use_function_names : bool, optional
+        Convert MAPDL functions to ansys.mapdl.core.Mapdl class
+        methods.  When ``True``, the MAPDL command "K" will be
+        converted to ``mapdl.k``.  When ``False``, it will be
+        converted to ``mapdl.run('k')``.
+
+    Returns
+    -------
+    list
+        List of lines translated.
+
+    """
+
+    translator = _convert(apdl_strings,
+    loglevel=loglevel,
+    auto_exit=auto_exit,
+    line_ending=line_ending,
+    exec_file=exec_file,
+    macros_as_functions=macros_as_functions,
+    use_function_names=use_function_names)
+
+    if isinstance(apdl_strings, str):
+        return translator.line_ending.join(translator.lines)
+    return translator.lines
+
+
+def _convert(apdl_strings,
+    loglevel="WARNING",
+    auto_exit=True,
+    line_ending=None,
+    exec_file=None,
+    macros_as_functions=True,
+    use_function_names=True,
+             ):
+
     translator = FileTranslator(
         loglevel,
         line_ending,
         exec_file=exec_file,
         macros_as_functions=macros_as_functions,
         use_function_names=use_function_names,
     )
-    with open(filename_in) as file_in:
-        for line in file_in.readlines():
-            translator.translate_line(line)
+
+    if isinstance(apdl_strings, str):
+        apdl_strings = apdl_strings.split(translator.line_ending)
+
+    for line in apdl_strings:
+        translator.translate_line(line)
 
     if auto_exit:
         translator.write_exit()
-    translator.save(filename_out)
-    return translator.lines
+    return translator
 
 
 class FileTranslator:
@@ -107,7 +192,30 @@ def __init__(
         self.initialize_mapdl_object(loglevel, exec_file)
 
         self._valid_commands = dir(Commands)
-        self._non_interactive_commands = ["*CRE", "*VWR"]
+        self._block_commands = {
+            "NBLO": "NBLOCK",
+            "EBLO": "EBLOCK",
+            "BFBL": "BFBLOCK",
+            "BFEB": "BFEBLOCK",
+            "PREA": "PREAD",
+            "SFEB": "SFEBLOCK"} #Way out: '-1' , 'END PREAD'
+
+        self._enum_block_commands = {
+            "CMBL": "CMBLOCK",
+        } # Commands where you need to count the number of lines.
+
+        _NON_INTERACTIVE_COMMANDS = {
+            "*CRE" : "*CREATE",
+            "*VWR" : "*VWRITE",
+            "*VRE" : "*VREAD"
+        }
+
+        self._non_interactive_commands = list(_NON_INTERACTIVE_COMMANDS) + list(self._block_commands) + list(self._enum_block_commands)
+
+        self._block_count = 0
+        self._block_count_target = 0
+        self._in_block = False
+        self._block_current_cmd = None
 
     def write_header(self):
         header = f'"""Script generated by ansys-mapdl-core version {__version__}"""'
@@ -152,6 +260,15 @@ def translate_line(self, line):
         line = line.strip()
         line = line.replace('"', "'")
 
+        if self._in_block:
+            self._block_count += 1
+
+        if self._in_block and self._block_count >= self._block_count_target and self._block_count_target:
+            self._in_block = False
+            self.end_non_interactive()
+            self._block_count = 0
+            self._block_current_cmd = None
+
         # check if line contains a comment
         if "!" in line:
             if "'!'" in line or '"!"' in line:
@@ -168,6 +285,34 @@ def translate_line(self, line):
 
         if not line:
             return
+        cmd_ = line.split(',')[0].upper()
+
+        if cmd_ == '*DO':
+            self.start_non_interactive()
+            self.store_run_command(line)
+            return
+
+        if cmd_ == '*ENDDO':
+            self.store_run_command(line)
+            self.end_non_interactive()
+            return
+
+        if self.output_to_file(line):
+            self.start_non_interactive()
+            self.store_run_command(line)
+            return
+
+        if self.output_to_default(line):
+            self.end_non_interactive()
+            self.store_run_command(line)
+            self.store_run_command('/GOPR')
+            return
+
+        if cmd_ == '/VERIFY':
+            self.store_run_command("FINISH")
+            self.store_run_command(line)
+            self.store_run_command("/PREP7")
+            return
 
         if line[:4].upper() == "*REP":
             if not self.non_interactive:
@@ -188,8 +333,17 @@ def translate_line(self, line):
             return self.store_command("title", ["".join(parameters).strip()])
 
         if line[:4].upper() == "*GET":
-            parameters = line.split(",")[1:]
-            return self.store_command("get", parameters)
+            if self.non_interactive: # gives error
+                self.store_run_command(line)
+                return
+            else:
+                parameters = line.split(",")[1:]
+                return self.store_command("get", parameters)
+
+        if line[:4].upper() == "/NOP":
+            self.comment = "It is not recommended to use '/NOPR' in a normal PyMAPDL session."
+            self.store_under_scored_run_command(line)
+            return
 
         if line[:6].upper() == "/PREP7":
             return self.store_command("prep7", [])
@@ -200,11 +354,13 @@ def translate_line(self, line):
                 self.store_empty_line()
                 self.indent = self.indent[4:]
                 self._infunction = False
-                self.end_non_interactive()
+                if not self._in_block:
+                    self.end_non_interactive()
                 return
             else:
                 self.store_run_command(line)
-                self.end_non_interactive()
+                if not self._in_block:
+                    self.end_non_interactive()
                 return
 
         # check for if statement
@@ -216,12 +372,14 @@ def translate_line(self, line):
         # check if line ends non-interactive
         if line[0] == "(":
             if not self.non_interactive:
-                print(
-                    "Possible invalid line:\n%s\n" % line
-                    + "This line requires a *VWRITE beforehand"
+                warn(
+                    "\nPossible invalid line:\n%s\n" % line
+                    + "This line requires a *VWRITE beforehand."
+                    + "The previous line is: \n%s\n\n" % self.lines[-1]
                 )
             self.store_run_command(line)
-            self.end_non_interactive()
+            if not self._in_block:  # To escape cmds that require (XX) but they are not in block
+                self.end_non_interactive()
             return
         elif line[:4] == "*USE" and self.macros_as_functions:
             items = line.split(",")
@@ -243,15 +401,36 @@ def translate_line(self, line):
             self.store_empty_line()
             return
 
+        if line == '-1' or line == 'END PREAD':  # End of block commands
+            self.store_run_command(line)
+            self._in_block = False
+            self.end_non_interactive()
+            return
+
         # check valid command
         if command not in self._valid_commands:
-            if line[:4] == "*CRE":  # creating a function
+            if line[:4].upper() == "*CRE":  # creating a function
                 if self.macros_as_functions:
                     self.start_function(items[1].strip())
                     return
                 else:
                     self.start_non_interactive()
-            elif line[:4] in self._non_interactive_commands:
+            elif line[:4].upper() in self._non_interactive_commands:
+                if line[:4].upper() in self._block_commands:
+                    self._in_block = True
+                    self._block_count = 0
+                    self._block_count_target = 0
+
+                elif line[:4].upper() in self._enum_block_commands:
+                    self._in_block = True
+                    self._block_count = 0
+                    if line[:4].upper() == 'CMBL': # In cmblock
+                        # CMBLOCK,Cname,Entity,NUMITEMS,,,,,KOPT
+                        numitems = int(line.split(',')[3])
+                        _block_count_target = numitems//8 + 1 if numitems%8 != 0 else numitems//8
+                        self._block_count_target = _block_count_target + 2 # because the cmd line and option line.
+
+                self._block_current_cmd = line[:4].upper()
                 self.start_non_interactive()
             self.store_run_command(line)
         elif self.use_function_names:
@@ -274,10 +453,18 @@ def start_function(self, func_name):
         self.lines.append(line)
         self.indent = self.indent + "    "
 
-    def store_run_command(self, command):
+    def store_under_scored_run_command(self, command):
+        self.store_run_command(command, run_underscored = True)
+
+    def store_run_command(self, command, run_underscored=False):
         """Stores pyansys.ANSYS command that cannot be broken down
         into a function and parameters.
         """
+        if run_underscored:
+            underscore = '_'
+        else:
+            underscore = ''
+
         if self._infunction and "ARG" in command:
             args = []
             for i in range(1, 19):
@@ -288,22 +475,24 @@ def store_run_command(self, command):
                     args.append(arg)
                     c += 1
 
-            line = '%s%s.run("%s".format(%s))' % (
+            line = '%s%s.%srun("%s".format(%s))' % (
                 self.indent,
                 self.obj_name,
+                underscore,
                 command,
                 ", ".join(args),
             )
 
         elif self.comment:
-            line = '%s%s.run("%s")  # %s' % (
+            line = '%s%s.%srun("%s")  # %s' % (
                 self.indent,
                 self.obj_name,
+                underscore,
                 command,
                 self.comment,
             )
         else:
-            line = '%s%s.run("%s")' % (self.indent, self.obj_name, command)
+            line = '%s%s.%srun("%s")' % (self.indent, self.obj_name, underscore, command)
         self.lines.append(line)
 
     def store_comment(self):
@@ -355,3 +544,41 @@ def end_non_interactive(self):
         if self._non_interactive_level == 0:
             self.non_interactive = False
             self.indent = self.indent[4:]
+
+    def output_to_file(self, line):
+        """Return if an APDL line is redirecting to a file."""
+        if line[:4].upper() == '/OUT':
+            # We are redirecting the output to somewhere, probably a file.
+            # Because of the problem with the ansys output, we need to execute
+            # this in non_interactive mode.
+            output_cmd = line.strip().upper().split(',')
+            if len(output_cmd) > 1:
+                opt1 = output_cmd[1].strip().upper()
+                if opt1 != 'TERM':
+                    # A file is supplied.
+                    return True
+
+        if line[:4].upper() == '*CFO':  # any([each[0:4] in '*CFOPEN' for each in dir(Commands)])
+            # We might not need going into interactive mode for *CFOPEN/*CFCLOSE
+            return True
+
+        return False
+
+    def output_to_default(self, line):
+        if line[:4].upper() == '/OUT':
+            # We are redirecting the output to somewhere, probably a file.
+            # Because of the problem with the ansys output, we need to execute
+            # this in non_interactive mode.
+            output_cmd = line.strip().upper().split(',')
+            if len(output_cmd) == 1:
+                return True
+            elif len(output_cmd) > 1:
+                opt1 = output_cmd[1].strip().upper()
+                if opt1 == 'TERM':
+                    # A file is supplied.
+                    return True
+        if line[:4].upper() in '*CFCLOSE':
+            # We might not need going into interactive mode for *CFOPEN/*CFCLOSE
+            return True
+
+        return False

ansys/mapdl/core/logging.py

@@ -148,6 +148,7 @@
     'DEBUG': DEBUG,
     'INFO': INFO,
     'WARN': WARN,
+    'WARNING': WARN,
     'ERROR': ERROR,
     'CRITICAL': CRITICAL,
 }