psdi-data-conversion 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

psdi_data_conversion/app.py

@@ -10,7 +10,7 @@ from argparse import ArgumentParser
 from psdi_data_conversion import constants as const
 from psdi_data_conversion.gui.env import update_env
 from psdi_data_conversion.gui.setup import get_app, limit_upload_size, start_app
-from psdi_data_conversion.main import print_wrap
+from psdi_data_conversion.utils import print_wrap
 
 app = get_app()
 

psdi_data_conversion/converters/openbabel.py

@@ -12,6 +12,7 @@ from openbabel import openbabel
 
 from psdi_data_conversion.converters.base import FileConverter, FileConverterInputException
 from psdi_data_conversion.security import SAFE_STRING_RE, string_is_safe
+from psdi_data_conversion.utils import print_wrap
 
 CONVERTER_OB = 'Open Babel'
 
@@ -83,30 +84,34 @@ class OBFileConverter(FileConverter):
     `run_converter()` through providing a dict to the `data` kwarg. The supported keys and values are:
 
     "from_flags": str
-        String of concatenated one-letter flags for how to read the input file. To list the flags supported for a given
-        input format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look for the
-        "Allowed input flags" section, if one exists, or alternatively call the library function
+        String of concatenated one-letter flags for how to write the output file, e.g. ``"from_flags": "xyz"`` will set
+        flags x, y and z. To list the flags supported for a given output format, call
+        ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look for the "Allowed input flags"
+        section, if one exists, or alternatively call the library function
         ``psdi_data_conversion.database.get_in_format_args("Open Babel", <format>)`` from within Python code.
 
     "to_flags": str
-        String of concatenated one-letter flags for how to write the output file. To list the flags supported for a
-        given output format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look for
-        the "Allowed output flags" section, if one exists, or alternatively call the library function
+        String of concatenated one-letter flags for how to write the output file, e.g. ``"to_flags": "xyz"`` will set
+        flags x, y and z. To list the flags supported for a given output format, call
+        ``psdi-data-convert -l -t <format> -w Open Babel`` at the command-line and look for the "Allowed output flags"
+        section, if one exists, or alternatively call the library function
         ``psdi_data_conversion.database.get_out_format_args("Open Babel", <format>)`` from within Python code.
 
     "from_options": str
         String of space-separated options for how to read the input file. Each option "word" in this string should start
-        with the letter indicating which option is being used, followed by the value for that option. To list the
+        with the letter indicating which option is being used, followed by the value for that option. E.g.
+        ``"from_options": "a1 b2"`` will set the value 1 for option a and the value 2 for option b. To list the
         options supported for a given input format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the
         command-line and look for the "Allowed input options" section, if one exists, or alternatively call the library
         function ``psdi_data_conversion.database.get_in_format_args("Open Babel", <format>)`` from within Python code.
 
     "to_options": str
         String of space-separated options for how to write the output file. Each option "word" in this string should
-        start with the letter indicating which option is being used, followed by the value for that option. To list the
+        start with the letter indicating which option is being used, followed by the value for that option. E.g.
+        ``"to_options": "a1 b2"`` will set the value 1 for option a and the value 2 for option b. To list the
         options supported for a given output format, call ``psdi-data-convert -l -t <format> -w Open Babel`` at the
         command-line and look for the "Allowed output options" section, if one exists, or alternatively call the library
-        function ``psdi_data_conversion.database.get_out_format_args("Open Babel", <format>)`` from within Python code.
+        function ``psdi_data_conversion.database.get_in_format_args("Open Babel", <format>)`` from within Python code.
 
     "coordinates": str
         One of "Gen2D", "Gen3D", or "neither", specifying how positional coordinates should be generated in the output
@@ -159,13 +164,28 @@ class OBFileConverter(FileConverter):
             from_args = self.data.get("from_args", "")
             to_args = self.data.get("to_args", "")
 
+            from psdi_data_conversion.database import (FileConverterDatabaseException, get_in_format_args,
+                                                       get_out_format_args)
+
             # Add option flags and arguments as appropriate
             for char in from_flags:
                 check_string_security(char)
+                # Check that the flag is valid
+                try:
+                    get_in_format_args(self.name, self.from_format_info, char)
+                except FileConverterDatabaseException:
+                    print_wrap(f"WARNING: Input format flag '{char}' not recognised for conversion with {self.name}. "
+                               "If this is valid, the database should be updated to indicate this.", err=True)
                 ob_conversion.AddOption(char, ob_conversion.INOPTIONS)
 
             for char in to_flags:
                 check_string_security(char)
+                # Check that the flag is valid
+                try:
+                    get_out_format_args(self.name, self.from_format_info, char)
+                except FileConverterDatabaseException:
+                    print_wrap(f"WARNING: Output format flag '{char}' not recognised for conversion with {self.name}. "
+                               "If this is valid, the database should be updated to indicate this", err=True)
                 ob_conversion.AddOption(char, ob_conversion.OUTOPTIONS)
 
             self.data["read_flags_args"] = []
@@ -176,37 +196,82 @@ class OBFileConverter(FileConverter):
             if "from_options" in self.data:
                 # From options were provided by the command-line script or library
                 l_from_options = self.data["from_options"].split()
+
                 for opt in l_from_options:
                     option, value = get_option_and_value(opt)
+
+                    # Check that the option is valid
+                    try:
+                        get_in_format_args(self.name, self.from_format_info, option)
+                    except FileConverterDatabaseException:
+                        print_wrap(f"WARNING: Input format option '{option}' not recognised for conversion with "
+                                   f"{self.name}. If this is valid, the database should be updated to indicate "
+                                   "this", err=True)
+
                     ob_conversion.AddOption(option, ob_conversion.INOPTIONS, value)
+
                 self.logger.debug(f"Set Open Babel read flags arguments to: {self.data['from_options']}")
                 # Store the options in the "read_flags_args" entry for the later logging
                 self.data["read_flags_args"] = l_from_options
+
             else:
                 # From options were provided by the command-line script or library
                 for char in from_arg_flags:
+
                     index = from_args.find('£')
                     arg, from_args = from_args[0:index], from_args[index + 1:len(from_args)]
                     check_string_security(char), check_string_security(arg)
+
+                    # Check that the option is valid
+                    try:
+                        get_in_format_args(self.name, self.from_format_info, arg)
+                    except FileConverterDatabaseException:
+                        print_wrap(f"WARNING: Input format option '{arg}' not recognised for conversion with "
+                                   f"{self.name}. If this is valid, the database should be updated to indicate "
+                                   "this.", err=True)
+
                     ob_conversion.AddOption(char, ob_conversion.INOPTIONS, arg)
                     self.data["read_flags_args"].append(char + "  " + arg)
+
                 self.logger.debug(f"Set Open Babel read flags arguments to: {self.data['read_flags_args']}")
 
             if "to_options" in self.data:
                 # From options were provided by the command-line script or library
                 l_to_options = self.data["to_options"].split()
+
                 for opt in l_to_options:
                     option, value = get_option_and_value(opt)
+
+                    # Check that the option is valid
+                    try:
+                        get_out_format_args(self.name, self.to_format_info, option)
+                    except FileConverterDatabaseException:
+                        print_wrap(f"WARNING: Output format option '{option}' not recognised for conversion with "
+                                   f"{self.name}. If this is valid, the database should be updated to indicate "
+                                   "this.", err=True)
+
                     ob_conversion.AddOption(option, ob_conversion.OUTOPTIONS, value)
+
                 self.logger.debug(f"Set Open Babel write flags arguments to: {self.data['to_options']}")
                 # Store the options in the "write_flags_args" entry for the later logging
                 self.data["write_flags_args"] = l_to_options
+
             else:
-                # From options were provided by the command-line script or library
+                # To options were provided by the command-line script or library
                 for char in to_arg_flags:
+
                     index = to_args.find('£')
                     arg, to_args = to_args[0:index], to_args[index + 1:len(to_args)]
                     check_string_security(char), check_string_security(arg)
+
+                    # Check that the option is valid
+                    try:
+                        get_out_format_args(self.name, self.to_format_info, arg)
+                    except FileConverterDatabaseException:
+                        print_wrap(f"WARNING: Output format option '{arg}' not recognised for conversion with "
+                                   f"{self.name}. If this is valid, the database should be updated to indicate "
+                                   "this.", err=True)
+
                     ob_conversion.AddOption(char, ob_conversion.OUTOPTIONS, arg)
                     self.data["write_flags_args"].append(char + "  " + arg)
                 self.logger.debug(f"Set Open Babel write flags arguments to: {self.data['read_flags_args']}")
@@ -239,6 +304,12 @@ class OBFileConverter(FileConverter):
         if "Open Babel Error" in self.err:
             self._abort_from_err()
 
+        # Check for any non-critical errors and print them out
+        l_err_blocks = self.err.split("\n\n")
+        for err_block in l_err_blocks:
+            if err_block.startswith("ERROR:") or err_block.startswith("WARNING:"):
+                print_wrap(err_block, err=True)
+
     def _create_message(self) -> str:
         """Overload method to create a log of options passed to the converter
         """
@@ -248,7 +319,7 @@ class OBFileConverter(FileConverter):
         label_length = 19
 
         for (label, key, multi) in (("Coord. gen.:", COORD_GEN_KEY, False),
-                                    ("Coord. option:", "coord_option", False),
+                                    ("Coord. option:", COORD_GEN_QUAL_KEY, False),
                                     ("Read options:", "from_flags", False),
                                     ("Write options:", "to_flags", False),
                                     ("Read opts + args:", "read_flags_args", True),

psdi_data_conversion/database.py

@@ -383,47 +383,69 @@ class ConverterInfo:
             self._d_out_format_options = self._create_d_format_args(OptionInfo, "out")
         return self._d_out_format_options
 
-    def get_in_format_args(self, name: str) -> tuple[list[FlagInfo], list[OptionInfo]]:
+    def get_in_format_args(self, in_format: str | int | FormatInfo) -> tuple[list[FlagInfo], list[OptionInfo]]:
         """Get the input flags and options supported for a given format (provided as its extension)
 
         Parameters
         ----------
-        name : str
-            The file format name (extension)
+        in_format : str
+            The file format name (extension), ID, or FormatInfo
 
         Returns
         -------
         tuple[set[FlagInfo], set[OptionInfo]]
             A set of info for the allowed flags, and a set of info for the allowed options
         """
-        l_flag_ids = list(self.d_in_format_flags.get(name, set()))
+
+        l_in_format_infos = get_format_info(in_format, which="all")
+        s_flag_ids = set()
+        s_option_ids = set()
+
+        for in_format_info in l_in_format_infos:
+            in_format_id = in_format_info.id
+
+            s_flag_ids.update(self.d_in_format_flags.get(in_format_id, set()))
+            s_option_ids.update(self.d_in_format_options.get(in_format_id, set()))
+
+        l_flag_ids = list(s_flag_ids)
         l_flag_ids.sort()
         l_flag_info = [self.l_in_flag_info[x] for x in l_flag_ids]
 
-        l_option_ids = list(self.d_in_format_options.get(name, set()))
+        l_option_ids = list(s_option_ids)
         l_option_ids.sort()
         l_option_info = [self.l_in_option_info[x] for x in l_option_ids]
 
         return l_flag_info, l_option_info
 
-    def get_out_format_args(self, name: str) -> tuple[list[FlagInfo], list[OptionInfo]]:
+    def get_out_format_args(self, out_format: str | int | FormatInfo) -> tuple[list[FlagInfo], list[OptionInfo]]:
         """Get the output flags and options supported for a given format (provided as its extension)
 
         Parameters
         ----------
-        name : str
-            The file format name (extension)
+        out_format : str
+            The file format name (extension), ID, or FormatInfo
 
         Returns
         -------
         tuple[set[FlagInfo], set[OptionInfo]]
             A set of info for the allowed flags, and a set of info for the allowed options
         """
-        l_flag_ids = list(self.d_out_format_flags.get(name, set()))
+
+        l_out_format_infos = get_format_info(out_format, which="all")
+        s_flag_ids = set()
+        s_option_ids = set()
+
+        for out_format_info in l_out_format_infos:
+            out_format_id = out_format_info.id
+
+            s_flag_ids.update(self.d_out_format_flags.get(out_format_id, set()))
+            s_option_ids.update(self.d_out_format_options.get(out_format_id, set()))
+
+        l_flag_ids = list(s_flag_ids)
         l_flag_ids.sort()
         l_flag_info = [self.l_out_flag_info[x] for x in l_flag_ids]
 
-        l_option_ids = list(self.d_out_format_options.get(name, set()))
+        l_option_ids = list(s_option_ids)
         l_option_ids.sort()
         l_option_info = [self.l_out_option_info[x] for x in l_option_ids]
 
@@ -1430,11 +1452,14 @@ def disambiguate_formats(converter_name: str,
         raise FileConverterDatabaseException(f"Conversion from {in_format} to {out_format} with converter "
                                              f"{converter_name} is not supported", help=True)
     else:
-        msg = (f"Conversion from {in_format} to {out_format} with converter {converter_name} is ambiguous.\n"
-               "Possible matching conversions are:\n")
+        msg = (f"Conversion from {in_format} to {out_format} with converter {converter_name} is ambiguous. Please "
+               "Use the ID or disambiguated name (listed below) of the desired conversion. Possible matching "
+               "conversions are:\n")
         for _, possible_in_format, possible_out_format in l_possible_conversions:
-            msg += (f"{possible_in_format.disambiguated_name} ({possible_in_format.note}) to "
-                    f"{possible_out_format.disambiguated_name} ({possible_out_format.note})\n")
+            msg += (f"    {possible_in_format.id}: {possible_in_format.disambiguated_name} "
+                    f"({possible_in_format.note}) to "
+                    f"{possible_out_format.id}: {possible_out_format.disambiguated_name} "
+                    f"({possible_out_format.note})\n")
         # Trim the final newline from the message
         msg = msg[:-1]
         raise FileConverterDatabaseException(msg, help=True)

psdi_data_conversion/main.py

@@ -26,20 +26,7 @@ from psdi_data_conversion.database import (FormatInfo, get_conversion_pathway, g
                                            get_out_format_args, get_possible_conversions, get_possible_formats)
 from psdi_data_conversion.file_io import split_archive_ext
 from psdi_data_conversion.log_utility import get_log_level_from_str
-from psdi_data_conversion.utils import regularize_name
-
-
-def print_wrap(s: str, newline=False, err=False, **kwargs):
-    """Print a string wrapped to the terminal width
-    """
-    if err:
-        file = sys.stderr
-    else:
-        file = sys.stdout
-    for line in s.split("\n"):
-        print(textwrap.fill(line, width=TERM_WIDTH, **kwargs), file=file)
-    if newline:
-        print("")
+from psdi_data_conversion.utils import print_wrap, regularize_name
 
 
 class ConvertArgs:
@@ -260,29 +247,29 @@ def get_argument_parser():
     parser.add_argument("--delete-input", action="store_true",
                         help="If set, input files will be deleted after conversion, default they will be kept")
     parser.add_argument("--from-flags", type=str, default="",
-                        help="Any command-line flags to be provided to the converter for reading in the input file(s). "
-                             "For information on the flags accepted by a converter and its required format for them, "
-                             "call this script with '-l <converter name>'. If the set of flags includes any spaces, it "
-                             "must be quoted, and if hyphens are used, the first preceding hyphen for each flag must "
-                             "be backslash-escaped, e.g. '--from-flags \"\\-a \\-bc \\--example\"'")
+                        help="String of concatenated one-letter flags for how to read the input file, e.g. "
+                        "``--from-flags xyz`` will set flags x, y, and z. To list the flags supported for a given "
+                        "input format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line "
+                        "and look for the \"Allowed input flags\" section, if one exists.")
     parser.add_argument("--to-flags", type=str, default="",
-                        help="Any command-line flags to be provided to the converter for writing the output file(s). "
-                             "For information on the flags accepted by a converter and its required format for them, "
-                             "call this script with '-l <converter name>'. If the set of flags includes any spaces, it "
-                             "must be quoted, and if hyphens are used, the first preceding hyphen for each flag must "
-                             "be backslash-escaped, e.g. '--to-flags \"\\-a \\-bc \\--example\"'")
+                        help="String of concatenated one-letter flags for how to write the output file, e.g. "
+                        "``--from-flags xyz`` will set flags x, y, and z. To list the flags supported for a given "
+                        "output format, call ``psdi-data-convert -l -t <format> -w Open Babel`` at the command-line "
+                        "and look for the \"Allowed output flags\" section, if one exists.")
     parser.add_argument("--from-options", type=str, default="",
-                        help="Any command-line options to be provided to the converter for reading in the input "
-                             "file(s). For information on the options accepted by a converter and its required format "
-                             "for them, call this script with '-l <converter name>'. If the set of options includes "
-                             "any spaces, it must be quoted, and the first preceding hyphen for each option must be "
-                             "backslash-escaped, e.g. '--from-options \"\\-x xval --opt optval\"'")
+                        help="String of space-separated options for how to read the input file. Each option \"word\" "
+                        "in this string should start with the letter indicating which option is being used, followed "
+                        "by the value for that option. E.g. ``--from_options a1 b2`` will set the value 1 for "
+                        "option a and the value 2 for option b. To list the options supported for a given input "
+                        "format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look "
+                        "for the \"Allowed input options\" section, if one exists.")
     parser.add_argument("--to-options", type=str, default="",
-                        help="Any command-line options to be provided to the converter for writing the output "
-                             "file(s). For information on the options accepted by a converter and its required format "
-                             "for them, call this script with '-l <converter name>'. If the set of options includes "
-                             "any spaces, it must be quoted, and the first preceding hyphen for each option must be "
-                             "backslash-escaped, e.g. '--to-options \"\\-x xval --opt optval\"'")
+                        help="String of space-separated options for how to write the output file. Each option \"word\" "
+                        "in this string should start with the letter indicating which option is being used, followed "
+                        "by the value for that option. E.g. ``--to_options a1 b2`` will set the value 1 for "
+                        "option a and the value 2 for option b. To list the options supported for a given output "
+                        "format, call ``psdi-data-convert -l -t <format> -w Open Babel`` at the command-line and look "
+                        "for the \"Allowed input options\" section, if one exists.")
     parser.add_argument("-s", "--strict", action="store_true",
                         help="If set, will fail if one of the input files has the wrong extension (including those "
                         "contained in archives, but not the archive files themselves). Otherwise, will only print a "
@@ -399,13 +386,17 @@ def detail_converter_use(args: ConvertArgs):
 
         print_wrap(f"File formats supported by {converter_name}:", newline=True)
         max_format_length = max([len(x.disambiguated_name) for x in l_all_formats])
-        print(" "*(max_format_length+4) + "   INPUT  OUTPUT")
-        print(" "*(max_format_length+4) + "   -----  ------")
+        print(" "*(max_format_length+4) + "    INPUT    OUTPUT    DESCRIPTION")
+        print(" "*(max_format_length+4) + "    -----    ------    -----------")
         for file_format in l_all_formats:
             in_yes_or_no = "yes" if file_format in l_input_formats else "no"
             out_yes_or_no = "yes" if file_format in l_output_formats else "no"
-            print(f"    {file_format.disambiguated_name:>{max_format_length}}{in_yes_or_no:>8}{out_yes_or_no:>8}")
-        print("")
+            print(f"    {file_format.disambiguated_name:>{max_format_length}}    {in_yes_or_no:<9}{out_yes_or_no:<10}"
+                  f"{file_format.note}")
+        print_wrap("\nFor more information on a format, including its ID (which can be used to specify it uniquely in "
+                   "case of ambiguity, and is resilient to database changes affecting the disambiguated names listed "
+                   "above), call:\n"
+                   f"{CL_SCRIPT_NAME} -l -f <format>", newline=True)
 
     if converter_class.allowed_flags is None:
         print_wrap("Information has not been provided about general flags accepted by this converter.", newline=True)

psdi_data_conversion/utils.py

@@ -5,6 +5,25 @@ Miscellaneous utility functions used by this project
 """
 
 
+import sys
+import textwrap
+
+from psdi_data_conversion.constants import TERM_WIDTH
+
+
+def print_wrap(s: str, newline=False, err=False, **kwargs):
+    """Print a string wrapped to the terminal width
+    """
+    if err:
+        file = sys.stderr
+    else:
+        file = sys.stdout
+    for line in s.split("\n"):
+        print(textwrap.fill(line, width=TERM_WIDTH, **kwargs), file=file)
+    if newline:
+        print("")
+
+
 def regularize_name(name: str):
     """Regularizes a name for comparisons, making it lowercase and stripping spaces
 

{psdi_data_conversion-0.2.2.dist-info → psdi_data_conversion-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psdi_data_conversion
-Version: 0.2.2
+Version: 0.2.4
 Summary: Chemistry file format conversion service, provided by PSDI
 Project-URL: Homepage, https://data-conversion.psdi.ac.uk/
 Project-URL: Documentation, https://psdi-uk.github.io/psdi-data-conversion/
@@ -293,6 +293,7 @@ This is the repository for the PSDI PF2 Chemistry File Format Conversion project
     - [Input file is malformatted or corrupt](#input-file-is-malformatted-or-corrupt)
     - [Input file's format is misidentified](#input-files-format-is-misidentified)
     - [Other known issues](#other-known-issues)
+- [Feedback](#feedback)
 - [Licensing](#licensing)
 - [Contributors](#contributors)
 - [Funding](#funding)
@@ -484,12 +485,17 @@ options] [-s/--strict] [--nc/--no-check] [-q/--quiet] [-g/--log-file <log file n
 
 Call `psdi-data-convert -h` for details on each of these options.
 
-Note that some requested conversions may involve ambiguous formats which share the same extension. In this case, the application will print a warning and list possible matching formats, with a disambiguating name that can be used to specify which one. For instance, the `c2x` converter can convert into two variants of the `pdb` format, and if you ask it to convert to `pdb` without specifying which one, you'll see:
+Note that some requested conversions may involve ambiguous formats which share the same extension. In this case, the application will print a warning and list possible matching formats, with IDs and disambiguating names that can be used to specify which one. For instance, the `c2x` converter can convert into two variants of the `pdb` format, and if you ask it to convert to `pdb` without specifying which one, you'll see:
 
 ```
-ERROR: Extension 'pdb' is ambiguous and must be defined by ID. Possible formats and their IDs are:
+WARNING: Format 'pdb' is ambiguous and could refer to multiple formats. It may be necessary to explicitly specify which
+you want to use when calling this script, e.g. with '-f pdb-0' - see the disambiguated names in the list below:
+
 9: pdb-0 (Protein Data Bank)
+...
+
 259: pdb-1 (Protein Data Bank with atoms numbered)
+...
 ```
 
 This provides the IDs ("9" and "259") and disambiguating names ("pdb-0" and "pdb-1") for the matching formats. Either can be used in the call to the converter, e.g.:
@@ -745,38 +751,69 @@ To remedy this, try explicitly specifying the format, rather than letting the ap
 `<format>` here can be the standard extension of the format (in the case of unambiguous extensions), its ID, or its disambiguated name. To give an example which explains what each of these are, let's say you have an MDL MOL file you wish to convert to XYZ, so you get information about it and possible converters with `psdi-data-convert -l -f mol -t xyz`:
 
 ```base
-$ psdi-data-convert -l -f mol
+$ psdi-data-convert -l -f mol -t xyz
 WARNING: Format 'mol' is ambiguous and could refer to multiple formats. It may be necessary to explicitly specify which
 you want to use when calling this script, e.g. with '-f mol-0' - see the disambiguated names in the list below:
 
 18: mol-0 (MDL MOL)
+- Atomic composition is supported
+- Atomic connections are supported
+- 2D atomic coordinates are supported
+- 3D atomic coordinates are supported
+
 216: mol-1 (MOLDY)
+- Atomic composition is unknown whether or not to be supported
+- Atomic connections are unknown whether or not to be supported
+- 2D atomic coordinates are unknown whether or not to be supported
+- 3D atomic coordinates are unknown whether or not to be supported
+
+WARNING: Format 'xyz' is ambiguous and could refer to multiple formats. It may be necessary to explicitly specify which
+you want to use when calling this script, e.g. with '-f xyz-0' - see the disambiguated names in the list below:
 
-20: xyz (XYZ cartesian coordinates)
+20: xyz-0 (XYZ cartesian coordinates)
+- Atomic composition is supported
+- Atomic connections are not supported
+- 2D atomic coordinates are supported
+- 3D atomic coordinates are supported
 
-The following registered converters can convert from mol-0 to xyz:
+284: xyz-1 (Extended XYZ (adds lattice vectors))
+- Atomic composition is unknown whether or not to be supported
+- Atomic connections are unknown whether or not to be supported
+- 2D atomic coordinates are unknown whether or not to be supported
+- 3D atomic coordinates are unknown whether or not to be supported
+
+The following registered converters can convert from mol-0 to xyz-0:
 
     Open Babel
     c2x
 
 For details on input/output flags and options allowed by a converter for this conversion, call:
-psdi-data-convert -l <converter name> -f mol-0 -t xyz
+psdi-data-convert -l <converter name> -f mol-0 -t xyz-0
+
+The following registered converters can convert from mol-0 to xyz-1:
 
-The following registered converters can convert from mol-1 to xyz:
+    c2x
+
+For details on input/output flags and options allowed by a converter for this conversion, call:
+psdi-data-convert -l <converter name> -f mol-0 -t xyz-1
+
+The following registered converters can convert from mol-1 to xyz-0:
 
     Atomsk
 
 For details on input/output flags and options allowed by a converter for this conversion, call:
-psdi-data-convert -l <converter name> -f mol-1 -t xyz
+psdi-data-convert -l <converter name> -f mol-1 -t xyz-0
+
+No converters are available which can perform a conversion from mol-1 to xyz-1
 ```
 
-This output indicates that the application is aware of two formats which share the `mol` extension: MDL MOL and MOLDY. It lists the ID, disambiguated name, and description of each: ID `18` and disambiguated name `mol-0` for MDL MOL, and ID `216` and disambiguated name `mol-1` for MOLDY. The XYZ format, on the other hand, is unambiguous, and only lists the standard extension for it as its disambiguated name (although `xyz-0` will be accepted without error as well).
+This output indicates that the application is aware of two formats which share the `mol` extension: MDL MOL and MOLDY. It lists the ID, disambiguated name, and description of each: ID `18` and disambiguated name `mol-0` for MDL MOL, and ID `216` and disambiguated name `mol-1` for MOLDY. The XYZ format similarly has two variants which can be converted to.
 
 The program then lists converters which can handle the requested conversion, revealing a potential pitfall: The Open Babel and c2x converters can convert from MDL MOL to XYZ, which the Atomsk converter can convert from MOLDY to XYZ. If you don't specify which format you're converting from, the script might assume you meant to use the other one, if that's the only one compatible with the converter you've requested (or with the default converter, Open Babel, if you didn't explicitly request one). So to be careful here, it's best to specify this input format unambiguously.
 
 Since in this example you have an MDL MOL file, you would use `-f 18` or `-f mol-0` to explicitly specify it in the command-line, or similarly provide one of these to the `from_format` argument of `run_converter` within Python. The application will then properly handle it, including alerting you if you request a conversion that isn't supported by your requested converter (e.g. if you request a conversion of this MDL MOL file to XYZ with Atomsk).
 
-Important note: The disambiguated name is generated dynamically and isn't stored in the database, and in rare cases may change for some formats in future versions of this application which expand support to more formats and conversions. For uses which require forward-compatibility with future versions of this application, the ID should be used instead.
+Important note: The disambiguated name is generated dynamically and isn't stored in the database, and in rare cases may change for some formats in future versions of this application which expand support to more formats and conversions. For uses which require forward-compatibility with future versions of this application, the ID should be used instead. You can obtain the ID for any format via the command: `psdi-data-convert -l -f <format-name>`.
 
 #### Other known issues
 
@@ -784,6 +821,10 @@ Through testing, we've identified some other conversion issues, which we list he
 
 - Open Babel will indefinitely hang when attempting to convert large files (more than ~1 MB) of certain types (such as `mmcif`). This is an issue with the converter itself and not our application, which we hope will be fixed in a future version. If this occurs, the job will have to be forcibly terminated. CTRL+C will fail to terminate it, but it can be stopped with CTRL+Z, then terminated with `kill %N`, where N is the number listed beside the job when it is stopped (usually 1). The conversion should then be attempted with another supported converter.
 
+## Feedback
+
+To report a missing format or conversion, please use [the form on the public web service](https://data-conversion.psdi.ac.uk/report.htm). Other feedback can be submitted on [the feedback page](https://data-conversion.psdi.ac.uk/static/content/feedback.htm).
+
 ## Licensing
 
 This project is provided under the Apache License version 2.0, the terms of which can be found in the file `LICENSE`.

{psdi_data_conversion-0.2.2.dist-info → psdi_data_conversion-0.2.4.dist-info}/RECORD

@@ -1,14 +1,14 @@
 psdi_data_conversion/__init__.py,sha256=urMsTqsTHTch1q4rMT9dgGnrvdPFMP9B8r-6Kr8H5sE,404
-psdi_data_conversion/app.py,sha256=VmZlIAZ_J9W6p_WUcTA_2UNmZxssmq1aT72I2d1ObDc,3606
+psdi_data_conversion/app.py,sha256=u26a6taxmS3Yn9o78hL1avpO-50BnbcMnJAuVn5XlEc,3607
 psdi_data_conversion/constants.py,sha256=eXE43_9YFahoehiUV7FtqN9MKb-UpSfY2win9ic9W8I,7348
 psdi_data_conversion/converter.py,sha256=OlwGKxI8nj76wrlVzP5S7fpXb6L-Ql8-mYLYGhW81Fk,27816
-psdi_data_conversion/database.py,sha256=0hSuvjpgj6OApNXhEPTzD4VAS8UY00RdtpFkaFsVXho,65564
+psdi_data_conversion/database.py,sha256=dJudFtSAXy814Ymw8ht9Lzfs4v-A6hv5k2busaXJlKU,66524
 psdi_data_conversion/dist.py,sha256=Db7mbLLANfugaptrcWCoVddwHT2rdP4X4HuP6uxr9AI,2309
 psdi_data_conversion/file_io.py,sha256=SE7cXVedm5ZLdxDQ7W7L2R9LXTqJz2Tak9-YTvc7_js,9250
 psdi_data_conversion/log_utility.py,sha256=CHAq-JvBnTKaE0SHK5hM5j2dTbfSli4iUc3hsf6dBhc,8789
-psdi_data_conversion/main.py,sha256=LWiYiELF_LY1GghQLt37eZS3ZNojmwHWuSnAhe3qbDI,44768
+psdi_data_conversion/main.py,sha256=_HmlDicG7TD7-taLNPazZS4rflXUU7ijHv3Tzx5kyLM,44770
 psdi_data_conversion/security.py,sha256=wjdrMre29TpkF2NqrsXJ5sschSAnDzqLYTLUcNR21Qw,902
-psdi_data_conversion/utils.py,sha256=iTjNfrD4n_hU9h20ldYrX2Bmp5KhCBIeMSUMLtPZ_8k,402
+psdi_data_conversion/utils.py,sha256=1DaTxoaUkoiImBYyXIiPToV2ae2eZEDPxbNWUvEqwDg,821
 psdi_data_conversion/bin/LICENSE_ATOMSK,sha256=-Ay6SFTAf9x-OaRAiOgMNoutfUMLHx5jQQA1HqZ6p7I,34886
 psdi_data_conversion/bin/LICENSE_C2X,sha256=-Ay6SFTAf9x-OaRAiOgMNoutfUMLHx5jQQA1HqZ6p7I,34886
 psdi_data_conversion/bin/linux/atomsk,sha256=GDsG1MlEvmk_XPspadzEzuil6N775iewDvNZS6rWJWk,34104032
@@ -19,7 +19,7 @@ psdi_data_conversion/converters/__init__.py,sha256=15Ldt06eyZ0bgNPB4qg419U0Zcjt6
 psdi_data_conversion/converters/atomsk.py,sha256=_V33me1e4HW0-YXvdE-z6PdwtSK2gYV6QZf5d8aPqH4,1523
 psdi_data_conversion/converters/base.py,sha256=yGlwQmYcLSKP9DH2reTBGvJ-HhfxjO_dYo6qVX501Zw,36515
 psdi_data_conversion/converters/c2x.py,sha256=jDA84H8Jpz--ajTWNWX6K6oMfOMMbMxkA31-VnGi0gU,2019
-psdi_data_conversion/converters/openbabel.py,sha256=OYppOMfnvxmVgRY5vUkcVokWn-bQSSeG8MOFqN1MCIY,13224
+psdi_data_conversion/converters/openbabel.py,sha256=2S3WZcYpS-FhKv2lqYndTWn-FNh8LeX3-Kc1nGw0y7s,16957
 psdi_data_conversion/gui/__init__.py,sha256=Q52GAaJWfNWGDOAEM_fIfAoivLIgM3krhVTiHFTRixM,125
 psdi_data_conversion/gui/accessibility.py,sha256=XQyAAJZQdIyRftfidhhVgsZXVtA9b9qZhwwFm899kbE,1302
 psdi_data_conversion/gui/env.py,sha256=nVuKzuE6z9ItH09ZRkooGRUTVZSHtPzSR9XrZVDHC-0,9235
@@ -87,8 +87,8 @@ psdi_data_conversion/testing/conversion_callbacks.py,sha256=ATR-_BsYCUN8KyOyUjfd
 psdi_data_conversion/testing/conversion_test_specs.py,sha256=PFzTZYonQ0PsZBKjcn0Hp-UPbwphT3zRH5v-VdNImmQ,27585
 psdi_data_conversion/testing/gui.py,sha256=ul7ixYANIzmOG2ZNOZmQO6wsHmGHdiBGAlw-KuoN0j8,19085
 psdi_data_conversion/testing/utils.py,sha256=uhJQUceaNmpQd3SioFLZVMExMVzO3Ds8V9DD2hqP-mQ,26700
-psdi_data_conversion-0.2.2.dist-info/METADATA,sha256=pIAVKNVVo-_VO3lbTA-MTvuR7t9LvUfHoIj0CD30imw,48538
-psdi_data_conversion-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-psdi_data_conversion-0.2.2.dist-info/entry_points.txt,sha256=xL7XTzaPRr2E67WhOD1M1Q-76hB8ausQlnNiHzuZQPA,123
-psdi_data_conversion-0.2.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-psdi_data_conversion-0.2.2.dist-info/RECORD,,
+psdi_data_conversion-0.2.4.dist-info/METADATA,sha256=hlT0b9qN26H0fVAnNI7euuBjKKVl_VUR1SLAdAzJtBg,50396
+psdi_data_conversion-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+psdi_data_conversion-0.2.4.dist-info/entry_points.txt,sha256=xL7XTzaPRr2E67WhOD1M1Q-76hB8ausQlnNiHzuZQPA,123
+psdi_data_conversion-0.2.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+psdi_data_conversion-0.2.4.dist-info/RECORD,,