psdi-data-conversion 0.2.1__tar.gz → 0.2.3__tar.gz

{psdi_data_conversion-0.2.1 → psdi_data_conversion-0.2.3}/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog for PSDI Data Conversion
 
+## v0.2.3
+
+### New and Changed Functionality
+
+- When listing formats supported by a given converter in the command-line application, the description of each format will also be shown in the table
+- A warning will now be printed to stderr and logged if an unrecognised format flag or option is provided for conversion with Open Babel
+
+### Bugfixes
+
+- Fixed coordinate generation quality not being properly logged
+
+### Documentation Changes
+
+- Fixed help for the "--from-flags", "--from-options" etc. command-line options to properly describe how values should be provided for them
+- Add note to README about how to submit feedback and missing formats/conversion
+- Updated README discussion of format IDs and disambiguated names, and provided more information about how to get IDs when formats are listed or when an ambiguous conversion is requested
+
+## v0.2.2
+
+### Bugfixes
+
+- Fixed bug where c2x and Atomsk converters would fail if the current working directory wasn't the base directory of the project
+
+### Testing Changes
+
+- Disabled automated MacOS testing, which started failing due to an update on GitHub's end, while we decide how to fix it
+
 ## v0.2.1
 
 ### Bugfixes

{psdi_data_conversion-0.2.1 → psdi_data_conversion-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psdi_data_conversion
-Version: 0.2.1
+Version: 0.2.3
 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.1 → psdi_data_conversion-0.2.3}/README.md

@@ -43,6 +43,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)
@@ -234,12 +235,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.:
@@ -495,38 +501,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
 
@@ -534,6 +571,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.1 → psdi_data_conversion-0.2.3}/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-0.2.1 → psdi_data_conversion-0.2.3}/psdi_data_conversion/converters/base.py

@@ -20,6 +20,7 @@ from typing import Any
 from psdi_data_conversion import constants as const
 from psdi_data_conversion import log_utility
 from psdi_data_conversion.dist import bin_exists, get_bin_path, get_dist
+from psdi_data_conversion.file_io import get_package_path
 from psdi_data_conversion.security import SAFE_STRING_RE, string_is_safe
 
 try:
@@ -744,7 +745,9 @@ class ScriptFileConverter(FileConverter):
         if self.required_bin is not None:
             env["BIN_PATH"] = get_bin_path(self.required_bin)
 
-        process = subprocess.run(['sh', f'psdi_data_conversion/scripts/{self.script}', *self._get_script_args()],
+        script_abs_path = os.path.join(get_package_path(), "scripts", self.script)
+
+        process = subprocess.run(['sh', script_abs_path, *self._get_script_args()],
                                  env=env, capture_output=True, text=True)
 
         self.out = process.stdout

{psdi_data_conversion-0.2.1 → psdi_data_conversion-0.2.3}/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_in_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-0.2.1 → psdi_data_conversion-0.2.3}/psdi_data_conversion/database.py

@@ -24,6 +24,7 @@ from psdi_data_conversion import constants as const
 from psdi_data_conversion.converter import (L_REGISTERED_CONVERTERS, L_SUPPORTED_CONVERTERS,
                                             get_registered_converter_class)
 from psdi_data_conversion.converters.base import FileConverter, FileConverterException
+from psdi_data_conversion.file_io import get_package_path
 from psdi_data_conversion.utils import regularize_name
 
 # Keys for top-level and general items in the database
@@ -1206,10 +1207,7 @@ def get_database_path() -> str:
     str
     """
 
-    # For an interactive shell, __file__ won't be defined for this module, so use the constants module instead
-    reference_file = os.path.realpath(const.__file__)
-
-    qualified_database_filename = os.path.join(os.path.dirname(reference_file), const.DATABASE_FILENAME)
+    qualified_database_filename = os.path.join(get_package_path(), const.DATABASE_FILENAME)
 
     return qualified_database_filename
 
@@ -1432,11 +1430,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-0.2.1 → psdi_data_conversion-0.2.3}/psdi_data_conversion/dist.py

@@ -9,7 +9,7 @@ import os
 import shutil
 import sys
 
-import psdi_data_conversion
+from psdi_data_conversion.file_io import get_package_path
 
 # Labels for each platform (which we use for the folder in this project), and the head of the name each platform will
 # have in `sys.platform`
@@ -29,7 +29,7 @@ D_DIST_NAME_HEADS = {LINUX_LABEL: LINUX_NAME_HEAD,
 
 
 # Determine the fully-qualified binary directory when this module is first imported
-BIN_DIR: str = os.path.join(psdi_data_conversion.__path__[0], "bin")
+BIN_DIR: str = os.path.join(get_package_path(), "bin")
 
 
 def get_dist():

{psdi_data_conversion-0.2.1 → psdi_data_conversion-0.2.3}/psdi_data_conversion/file_io.py

@@ -7,12 +7,30 @@ Functions and classes related to general filesystem input/output
 
 import glob
 import os
+from functools import lru_cache
 from shutil import copyfile, make_archive, unpack_archive
 from tempfile import TemporaryDirectory
 
 from psdi_data_conversion import constants as const
 
 
+@lru_cache(maxsize=1)
+def get_package_path() -> str:
+    """Gets the absolute path to where the `psdi_data_conversion` package is on disk
+
+    Returns
+    -------
+    str
+    """
+
+    # For an interactive shell, __file__ won't be defined for this module, so use the constants module instead
+    reference_file = os.path.realpath(const.__file__)
+
+    package_path = os.path.dirname(reference_file)
+
+    return package_path
+
+
 def is_archive(filename: str) -> bool:
     """Uses a file's extension to check if it's an archive or not
     """