From d33c5b934f283d1ef6fe48b796c3786be96390cb Mon Sep 17 00:00:00 2001
From: VV <velizar.vesselinov@gmail.com>
Date: Mon, 24 Oct 2022 16:22:17 -0500
Subject: [PATCH] PSF black

---
 README.md             |   1 +
 setup.py              |  78 +++++-----
 uom/__init__.py       |   2 +-
 uom/cmd_line.py       |  23 ++-
 uom/tests/uom_test.py | 132 +++++++++--------
 uom/unit_alias.py     | 328 +++++++++++++++++++++---------------------
 uom/uom.py            |  63 ++++----
 uom/uomdata.py        |   2 +-
 8 files changed, 323 insertions(+), 306 deletions(-)

diff --git a/README.md b/README.md
index 95d7b92..648f44a 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,7 @@
 | Fossa | [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FSchlumberger%2FUOM.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FSchlumberger%2FUOM?ref=badge_shield) |
 | PyPI | [![PyPI Latest Release](https://img.shields.io/pypi/v/uom.svg)](https://pypi.org/project/uom/) [![Package Status](https://img.shields.io/pypi/status/uom.svg)](https://pypi.org/project/uom/) [![Python](https://img.shields.io/pypi/pyversions/uom.svg?style=plastic)](https://badge.fury.io/py/uom) |
 | PePy | [![Downloads](https://pepy.tech/badge/uom)](https://pepy.tech/project/uom) [![Downloads](https://pepy.tech/badge/uom/month)](https://pepy.tech/project/uom) [![Downloads](https://pepy.tech/badge/uom/week)](https://pepy.tech/project/uom) |
+| Code formatting | [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) |
 
 <!--
 ## Build package
diff --git a/setup.py b/setup.py
index 3ff014a..25d5f28 100644
--- a/setup.py
+++ b/setup.py
@@ -6,47 +6,53 @@
 
 def requirements():
     """Requirement from source."""
-    with open('requirements.txt', 'r', encoding='utf8') as fil:
+    with open("requirements.txt", "r", encoding="utf8") as fil:
         return fil.read().splitlines()
 
 
 def readme():
     """Readme from source."""
-    with open('README.md', 'r', encoding='utf8') as fil:
+    with open("README.md", "r", encoding="utf8") as fil:
         return fil.read()
 
 
-setup(name='uom',
-      version='0.6.1',
-      description='Unit of Measure conversion tool',
-      long_description=readme(),
-      long_description_content_type='text/markdown',
-      classifiers=['Development Status :: 5 - Production/Stable',
-                   'Environment :: Console',
-                   'Intended Audience :: Customer Service',
-                   'Intended Audience :: Developers',
-                   'Intended Audience :: Science/Research',
-                   'License :: OSI Approved :: BSD License',
-                   'Programming Language :: Python :: 3.6',
-                   'Programming Language :: Python :: 3.7',
-                   'Programming Language :: Python :: 3.8',
-                   'Programming Language :: Python :: 3.9',
-                   'Programming Language :: Python :: 3.10',
-                   'Topic :: Scientific/Engineering',
-                   'Topic :: Scientific/Engineering :: Information Analysis'],
-      keywords='uom unit measurement measure Energistics oilfield',
-      url='http://github.com/schlumberger/UOM',
-      author='Velizar VESSELINOV',
-      author_email='vvesselinov@slb.com',
-      license='BSD 2-Clause “Simplified” License',
-      license_file='LICENSE.md',
-      packages=['uom'],
-      install_requires=requirements(),
-      python_requires='>=3.6',
-      test_suite='uom.tests',
-      entry_points={
-          'console_scripts': ['uom_convert_value=uom.cmd_line:cmd_convert',
-                              'uom_base_unit=uom.cmd_line:cmd_base_unit'],
-      },
-      include_package_data=True,
-      zip_safe=False)
+setup(
+    name="uom",
+    version="0.6.2",
+    description="Unit of Measure conversion tool",
+    long_description=readme(),
+    long_description_content_type="text/markdown",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Environment :: Console",
+        "Intended Audience :: Customer Service",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: BSD License",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Topic :: Scientific/Engineering",
+        "Topic :: Scientific/Engineering :: Information Analysis",
+    ],
+    keywords="uom unit measurement measure Energistics oilfield",
+    url="http://github.com/schlumberger/UOM",
+    author="Velizar VESSELINOV",
+    author_email="vvesselinov@slb.com",
+    license="BSD 2-Clause “Simplified” License",
+    license_file="LICENSE.md",
+    packages=["uom"],
+    install_requires=requirements(),
+    python_requires=">=3.6",
+    test_suite="uom.tests",
+    entry_points={
+        "console_scripts": [
+            "uom_convert_value=uom.cmd_line:cmd_convert",
+            "uom_base_unit=uom.cmd_line:cmd_base_unit",
+        ],
+    },
+    include_package_data=True,
+    zip_safe=False,
+)
diff --git a/uom/__init__.py b/uom/__init__.py
index ea6be68..b104825 100644
--- a/uom/__init__.py
+++ b/uom/__init__.py
@@ -4,4 +4,4 @@
 from .unit_alias import unit_alias
 from .uom import base_unit, conversion_factors, convert
 
-__all__ = ['unit_alias', 'base_unit', 'conversion_factors', 'convert']
+__all__ = ["unit_alias", "base_unit", "conversion_factors", "convert"]
diff --git a/uom/cmd_line.py b/uom/cmd_line.py
index 3c160aa..38a12f9 100644
--- a/uom/cmd_line.py
+++ b/uom/cmd_line.py
@@ -8,17 +8,15 @@
 
 def cmd_convert(arg=None):
     """Convert value."""
-    parser = ArgumentParser(prog='uom_convert_value')
+    parser = ArgumentParser(prog="uom_convert_value")
 
-    parser.add_argument('value', type=float, nargs='+',
-                        help='value to be converted')
+    parser.add_argument("value", type=float, nargs="+", help="value to be converted")
 
-    parser.add_argument('-s', dest='source', help='unit source')
+    parser.add_argument("-s", dest="source", help="unit source")
 
-    parser.add_argument('-t', dest='target', help='unit target')
+    parser.add_argument("-t", dest="target", help="unit target")
 
-    parser.add_argument('-v', dest='verbose', action='store_true',
-                        help='verbose')
+    parser.add_argument("-v", dest="verbose", action="store_true", help="verbose")
 
     if arg is not None:
         args = parser.parse_args(arg.split())
@@ -33,19 +31,18 @@ def cmd_convert(arg=None):
         out = convert(args.value, args.source, args.target, args.verbose)
 
     if args.verbose:
-        print(f'Output: {out}')
+        print(f"Output: {out}")
 
     return out
 
 
 def cmd_base_unit(arg=None):
     """Base unit."""
-    parser = ArgumentParser(prog='uom_base_unit')
+    parser = ArgumentParser(prog="uom_base_unit")
 
-    parser.add_argument('unit', help='input unit')
+    parser.add_argument("unit", help="input unit")
 
-    parser.add_argument('-v', dest='verbose', action='store_true',
-                        help='verbose')
+    parser.add_argument("-v", dest="verbose", action="store_true", help="verbose")
 
     if arg is not None:
         args = parser.parse_args(arg.split())
@@ -57,6 +54,6 @@ def cmd_base_unit(arg=None):
     out = base_unit(args.unit, args.verbose)
 
     if args.verbose:
-        print(f'Output: {out}')
+        print(f"Output: {out}")
 
     return out
diff --git a/uom/tests/uom_test.py b/uom/tests/uom_test.py
index 66c3c6b..6713744 100644
--- a/uom/tests/uom_test.py
+++ b/uom/tests/uom_test.py
@@ -7,8 +7,13 @@
 
 from ..cmd_line import cmd_base_unit, cmd_convert
 from ..unit_alias import UNIT_ALIAS_DICT
-from ..uom import (base_conversion_factors, base_unit, conversion_factors,
-                   convert, unit_alias)
+from ..uom import (
+    base_conversion_factors,
+    base_unit,
+    conversion_factors,
+    convert,
+    unit_alias,
+)
 
 
 class UOMTestCase(TestCase):
@@ -18,24 +23,25 @@ class UOMTestCase(TestCase):
     def test_conversion_of_value(self):
         """Test conversion function."""
         tests = {
-            'ft/h => ft/s': [1, 'ft/h', 'ft/s', 0.0002777777777777778],
-            'm => ft': [10, 'm', 'ft', 32.80839895013123],
-            'psi => Pa': [1, 'psi', 'Pa', 6894.757293168361],
+            "ft/h => ft/s": [1, "ft/h", "ft/s", 0.0002777777777777778],
+            "m => ft": [10, "m", "ft", 32.80839895013123],
+            "psi => Pa": [1, "psi", "Pa", 6894.757293168361],
+            "psi => J/m3": [1, "psi", "J/m3", 6894.757293168361],
             #                             6894.7572931683608
             #                             6894.757293168
             # http://www.metric4us.com/calculator.html
             #                             6894.757293168362
             # python                      6894.757293168361
-            'Pa => psi': [1, 'Pa', 'psi', 0.0001450377377302092],
-            'N => J.m/m2': [1, 'N', 'J.m/m2', 1],
-            'J.m/m2 => N': [1, 'J.m/m2', 'N', 1],
-            'Hz => 1/s': [1, 'Hz', '1/s', 1],
-            '1/s => Hz': [1, '1/s', 'Hz', 1],
-            'ft => m': [30, 'ft', 'm', 9.144],
-            'N.m => J': [1, 'N.m', 'J', 1],
-            'W => J/s': [1, 'W', 'J/s', 1],
-            'kft.lbf => J': [1, 'kft.lbf', 'J', 1355.8179483314004],
-            'degC => degF': [22.4, 'degC', 'degF', 72.32]
+            "Pa => psi": [1, "Pa", "psi", 0.0001450377377302092],
+            "N => J.m/m2": [1, "N", "J.m/m2", 1],
+            "J.m/m2 => N": [1, "J.m/m2", "N", 1],
+            "Hz => 1/s": [1, "Hz", "1/s", 1],
+            "1/s => Hz": [1, "1/s", "Hz", 1],
+            "ft => m": [30, "ft", "m", 9.144],
+            "N.m => J": [1, "N.m", "J", 1],
+            "W => J/s": [1, "W", "J/s", 1],
+            "kft.lbf => J": [1, "kft.lbf", "J", 1355.8179483314004],
+            "degC => degF": [22.4, "degC", "degF", 72.32],
         }
 
         for k in sorted(tests):
@@ -59,37 +65,37 @@ def test_conversion_of_value(self):
         self.assertEqual(out, i[3])
 
         # source unit missing test
-        k = 'm => ft'
+        k = "m => ft"
         i = tests[k]
         out = convert(i[0], None, i[2])
 
         # convert uncompatible unit return None
-        out = convert(1, 'm', 'kg')
+        out = convert(1, "m", "kg")
 
         self.assertIsNone(out)
 
         # convert uncompatible unit_aliases return None
-        out = convert(1, 'gal/min', 'kft.lbf')
+        out = convert(1, "gal/min", "kft.lbf")
 
         self.assertIsNone(out)
 
         # convert none dimension unit return None
-        out = convert(1, 'B', 'gAPI')
+        out = convert(1, "B", "gAPI")
 
         self.assertIsNone(out)
 
         for k in sorted(tests):
             i = tests[k]
-            arg = f'{i[0]} -s={i[1]} -t={i[2]}'
-            print('\n===== arg:', arg)
+            arg = f"{i[0]} -s={i[1]} -t={i[2]}"
+            print("\n===== arg:", arg)
             out = cmd_convert(arg)
 
             self.assertEqual(out, i[3])
 
         for k in sorted(tests):
             i = tests[k]
-            arg = f'{i[0]} -s={i[1]} -t={i[2]} -v'
-            print('\n===== arg:', arg)
+            arg = f"{i[0]} -s={i[1]} -t={i[2]} -v"
+            print("\n===== arg:", arg)
             out = cmd_convert(arg)
 
             self.assertEqual(out, i[3])
@@ -99,15 +105,12 @@ def test_conversion_of_value(self):
 
     def test_conversion_unitless(self):
         """Test conversion of unitless function."""
-        tests = {
-            'u1': [10, '', 'unitless', 10],
-            'u2': [10, 'unitless', '', 10]
-        }
+        tests = {"u1": [10, "", "unitless", 10], "u2": [10, "unitless", "", 10]}
 
         for k in sorted(tests):
             i = tests[k]
-            arg = f'{i[0]} -s={i[1]} -t={i[2]}'
-            print('\n===== arg:', arg)
+            arg = f"{i[0]} -s={i[1]} -t={i[2]}"
+            print("\n===== arg:", arg)
             out = cmd_convert(arg)
 
             self.assertTrue(out == i[3])
@@ -115,104 +118,102 @@ def test_conversion_unitless(self):
     def test_conversion_of_list(self):
         """Test conversion of list function."""
         tests = {
-            'm => ft': [[10, 100], 'm', 'ft',
-                        [32.80839895013123, 328.0839895013123]],
+            "m => ft": [[10, 100], "m", "ft", [32.80839895013123, 328.0839895013123]],
         }
 
         for k in sorted(tests):
             i = tests[k]
-            arg = f'''{' '.join([str(x) for x in i[0]])} -s={i[1]} -t={i[2]}'''
+            arg = f"""{' '.join([str(x) for x in i[0]])} -s={i[1]} -t={i[2]}"""
 
-            print('\n===== arg:', arg)
+            print("\n===== arg:", arg)
             out = cmd_convert(arg)
 
             self.assertTrue(out == i[3])
 
     def test_conversion_of_dataframe(self):
         """Test conversion of list function."""
-        dtf = DataFrame({'m': [10, 100], 'ft':
-                         [32.80839895013123, 328.0839895013123]})
+        dtf = DataFrame({"m": [10, 100], "ft": [32.80839895013123, 328.0839895013123]})
 
-        out = convert(dtf['m'], 'm', 'ft')
+        out = convert(dtf["m"], "m", "ft")
 
-        self.assertTrue(dtf['ft'].equals(out))
+        self.assertTrue(dtf["ft"].equals(out))
 
     def test_bad_base_unit(self):
         """Test base_unit function with bad parameter."""
-        base = base_unit('jhdfkjshdfkjs')
+        base = base_unit("jhdfkjshdfkjs")
         self.assertIsNone(base)
 
-        base = base_unit('jhdfkjshdfkjs', True)
+        base = base_unit("jhdfkjshdfkjs", True)
         self.assertIsNone(base)
 
     def test_cmd_base_unit(self):
         """Test base_unit function with bad parameter."""
-        base = cmd_base_unit('jhdfkjshdfkjs')
+        base = cmd_base_unit("jhdfkjshdfkjs")
         self.assertIsNone(base)
 
-        base = cmd_base_unit('jhdfkjshdfkjs -v')
+        base = cmd_base_unit("jhdfkjshdfkjs -v")
         self.assertIsNone(base)
-        base = cmd_base_unit('psi')
-        self.assertEqual(base, 'J/m3')
+        base = cmd_base_unit("psi")
+        self.assertEqual(base, "J/m3")
 
     def test_bad_convert(self):
         """Test convert function with bad parameter."""
-        result = convert(10, 'jhdfkjshdfkjs', '', True)
+        result = convert(10, "jhdfkjshdfkjs", "", True)
         self.assertIsNone(result)
 
-        result = convert(10, '', 'jhdfkjshdfkjs')
+        result = convert(10, "", "jhdfkjshdfkjs")
         self.assertIsNone(result)
 
-        result = convert('aaa', '', 'jhdfkjshdfkjs')
+        result = convert("aaa", "", "jhdfkjshdfkjs")
         self.assertIsNone(result)
 
-        result = convert(10, None, 'jhdfkjshdfkjs')
+        result = convert(10, None, "jhdfkjshdfkjs")
         self.assertIsNone(result)
 
-        result = convert(10, 'jhdfkjshdfkjs', None)
+        result = convert(10, "jhdfkjshdfkjs", None)
         self.assertIsNone(result)
 
-        result = convert('m', 10, '')
+        result = convert("m", 10, "")
         self.assertIsNone(result)
 
-        result = convert('m', '', 10)
+        result = convert("m", "", 10)
         self.assertIsNone(result)
 
-        result = convert(10, '', '')
+        result = convert(10, "", "")
         self.assertEqual(result, 10)
 
-        result = convert(10, 'm', 'degC')
+        result = convert(10, "m", "degC")
         self.assertIsNone(result)
 
-        result = convert(10, 'm', 'degC', True)
+        result = convert(10, "m", "degC", True)
         self.assertIsNone(result)
 
     def test_bad_conversion_factors(self):
         """Test conversion_factors function with bad parameter."""
-        scale, offset = conversion_factors('jhdfkjshdfkjs', '', True)
+        scale, offset = conversion_factors("jhdfkjshdfkjs", "", True)
         self.assertIsNone(scale)
         self.assertIsNone(offset)
 
-        scale, offset = conversion_factors('', 'jhdfkjshdfkjs')
+        scale, offset = conversion_factors("", "jhdfkjshdfkjs")
         self.assertIsNone(scale)
         self.assertIsNone(offset)
 
     def test_base_unit_recursive(self):
         """Test base_unit recursive."""
-        base = base_unit('J.m/m2', True)
-        self.assertEqual(base, 'N')
+        base = base_unit("J.m/m2", True)
+        self.assertEqual(base, "N")
 
-        scale, offset = conversion_factors('Hz', '1/s', True)
+        scale, offset = conversion_factors("Hz", "1/s", True)
         self.assertEqual(scale, 1)
         self.assertEqual(offset, 0)
 
-        scale, offset = conversion_factors('m3/m3', '%', True)
+        scale, offset = conversion_factors("m3/m3", "%", True)
         self.assertEqual(scale, 100)
         self.assertEqual(offset, 0)
 
     def test_bad_base_conv_factors(self):
         """Test base_conversion_factors function with bad parameter."""
-        aaa, bbb, ccc = base_conversion_factors('jhdfkjshdfkjs', True)
+        aaa, bbb, ccc = base_conversion_factors("jhdfkjshdfkjs", True)
         self.assertIsNone(aaa)
         self.assertIsNone(bbb)
         self.assertIsNone(ccc)
@@ -224,9 +225,14 @@ def test_unit_alias(self):
             base = base_unit(unit)
             self.assertIsNotNone(base)
 
-        unit = unit_alias('jhdfkjshdfkjs')
-        self.assertEqual(unit, 'jhdfkjshdfkjs')
+        unit = unit_alias("jhdfkjshdfkjs")
+        self.assertEqual(unit, "jhdfkjshdfkjs")
+
+    def test_conv_without_target(self):
+        """Test conversion without target."""
+        out = cmd_convert("-s psi 1 -v")
+        self.assertEqual(out, 6894.757293168361)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/uom/unit_alias.py b/uom/unit_alias.py
index e9ce9df..d04d05a 100644
--- a/uom/unit_alias.py
+++ b/uom/unit_alias.py
@@ -2,170 +2,170 @@
 
 # Alias: UOM
 UNIT_ALIAS_DICT = {
-    'W/A': 'V',
-    'deg': 'dega',
-    'degr': 'dega',
-    'degrees': 'dega',
-    'DEGREE': 'dega',
-    'DEG': 'dega',
-    'DEGA': 'dega',
-    'DEGREES': 'dega',
-    'DEGS': 'dega',
-    'DG': 'dega',
-    'DMS': 'dega',
-    'Degree': 'dega',
-    'degA': 'dega',
-    '°': 'dega',
-    'lbm/gal': 'lbm/gal[US]',
-    'gal/min': 'gal[US]/min',
-    'galUS/min': 'gal[US]/min',
-    'GAL/MIN': 'gal[US]/min',
-    'GPM': 'gal[US]/min',
-    'USGAL/MIN': 'gal[US]/min',
-    'gpm': 'gal[US]/min',
-    'M3MN': 'm3/min',
-    'c/s': 'rev/s',
-    'cps': 'rev/s',
-    'CPS': 'rev/s',
-    'c/min': 'rpm',
-    'spm': '1/min',
-    'SPM': '1/min',
-    '1/MIN': '1/min',
-    'мин–1': '1/min',
-    'kft.lbf': '1000 lbf.ft',
-    'klbf.ft': '1000 lbf.ft',
-    'KFT.LBF': '1000 lbf.ft',
-    'Kft.lbs': '1000 lbf.ft',
-    'Klbf': '1000 lbf.ft',
-    'M': 'm',
-    'M3M2': 'm',
-    'METER': 'm',
-    'METERS': 'm',
-    'METRE': 'm',
-    'METRES': 'm',
-    'Meter': 'm',
-    'm3/m2': 'm',
-    'meter': 'm',
-    'metres': 'm',
-    'м': 'm',
-    'deg/100ft': '0.01 dega/ft',
-    'dega/100ft': '0.01 dega/ft',
-    '0.01 deg/ft': '0.01 dega/ft',
-    'feet': 'ft',
-    'FT': 'ft',
-    'foot': 'ft',
-    'FT/S': 'ft/s',
-    'ft/ht': 'ft/h',
-    'F/HR': 'ft/h',
-    'f/hr': 'ft/h',
-    'FT/H': 'ft/h',
-    'ft/hr': 'ft/h',
-    'FT/HR': 'ft/h',
-    'm/hr': 'm/h',
-    'M/HR': 'm/h',
-    '1/30 deg/m': '1/30 dega/m',
-    'deg/30m': '1/30 dega/m',
-    'deg/m': 'dega/m',
-    '1000 ft.lbf': '1000 lbf.ft',
-    '1000ft.lbf': '1000 lbf.ft',
-    '1000 lbf': 'klbf',
-    '1000lbf': 'klbf',
-    '1000 lbm': 'klbm',
-    'kkgf': 'Mgf',
-    'ppg': 'lbm/gal[US]',
-    'LB/G': 'lbm/gal[US]',
-    'lb/gal': 'lbm/gal[US]',
-    'LBM/GAL': 'lbm/gal[US]',
-    'PPA': 'lbm/gal[US]',
-    'PPG': 'lbm/gal[US]',
-    'PPGE': 'lbm/gal[US]',
-    'lb/U.S.gal': 'lbm/gal[US]',
-    'lbm/galUS': 'lbm/gal[US]',
-    '1000 kgf': 'Mgf',
-    'KKGF': 'Mgf',
-    'v': 'V',
-    'VOLT': 'V',
-    'Volts': 'V',
-    'volts': 'V',
-    'В': 'V',
-    'Mv': 'MV',
-    'DEGC': 'degC',
-    'Cel': 'degC',
-    'DEG C': 'degC',
-    'DEG_C': 'degC',
-    'DEGc': 'degC',
-    'DegC': 'degC',
-    'deg C': 'degC',
-    'oC': 'degC',
-    'lpm': 'L/min',
-    'л/мин': 'L/min',
-    '°C': 'degC',
-    'DEGF': 'degF',
-    'DegF': 'degF',
-    'deg F': 'degF',
-    'oF': 'degF',
-    '°F': 'degF',
-    'RPM': 'rpm',
-    'KLBF': 'klbf',
-    'KFLB': 'klbf',
-    'G': 'gn',
-    "G's": 'gn',
-    'hr': 'h',
-    'hour': 'h',
-    'HR': 'h',
-    'hrs': 'h',
-    'MINUTES': 'min',
-    'MIN': 'min',
-    'MINUTE': 'min',
-    'mins': 'min',
-    'мин': 'min',
-    'PSI': 'psi',
-    'APSI': 'psi',
-    'PSIA': 'psi',
-    'psia': 'psi',
-    'KPSI': 'kpsi',
-    'ft.lbf': 'lbf.ft',
-    'in.lbf': 'lbf.in',
-    'FLBF': 'lbf.in',
-    'ft-lbs': 'lbf.in',
-    'pa': 'Pa',
-    'PA': 'Pa',
-    'IN': 'in',
-    'db': 'dB',
-    'дБ': 'dB',
-    'kpa': 'kPa',
-    'KPA': 'kPa',
-    '1000 Pa': 'kPa',
-    'KPAA': 'kPa',
-    'kN/m2': 'kPa',
-    'kPaa': 'kPa',
-    'кПа': 'kPa',
-    'GAPI': 'gAPI',
-    'OHMM': 'ohm.m',
-    'kdan': '10 kN',
-    'kdaN': '10 kN',
-    'KDAN': '10 kN',
-    'HZ': 'Hz',
-    'pu': '%',
-    'PU': '%',
-    'PERC': '%',
-    'PCNT': '%',
-    'PERCENTAGE': '%',
-    'IN2': 'in2',
-    'LB': 'lbf',
-    'LBF': 'lbf',
-    'LBS': 'lbf',
-    'lbs': 'lbf',
-    'kg/(m.s2)': 'Pa',
-    'AHrs': 'A.h',
-    'amp-hours': 'A.h',
-    'degreesCelsius': 'degC',
-    'KNM': 'kN.m',
-    'KGM3': 'kg/m3',
-    'KDN': 'kdyne',
-    'RPG': 'rev/gal[US]',
-    '0.01 m3/m3': '0.01 bbl/bbl',
-    '0.001/(ohm.m)': 'mS'
+    "W/A": "V",
+    "deg": "dega",
+    "degr": "dega",
+    "degrees": "dega",
+    "DEGREE": "dega",
+    "DEG": "dega",
+    "DEGA": "dega",
+    "DEGREES": "dega",
+    "DEGS": "dega",
+    "DG": "dega",
+    "DMS": "dega",
+    "Degree": "dega",
+    "degA": "dega",
+    "°": "dega",
+    "lbm/gal": "lbm/gal[US]",
+    "gal/min": "gal[US]/min",
+    "galUS/min": "gal[US]/min",
+    "GAL/MIN": "gal[US]/min",
+    "GPM": "gal[US]/min",
+    "USGAL/MIN": "gal[US]/min",
+    "gpm": "gal[US]/min",
+    "M3MN": "m3/min",
+    "c/s": "rev/s",
+    "cps": "rev/s",
+    "CPS": "rev/s",
+    "c/min": "rpm",
+    "spm": "1/min",
+    "SPM": "1/min",
+    "1/MIN": "1/min",
+    "мин–1": "1/min",
+    "kft.lbf": "1000 lbf.ft",
+    "klbf.ft": "1000 lbf.ft",
+    "KFT.LBF": "1000 lbf.ft",
+    "Kft.lbs": "1000 lbf.ft",
+    "Klbf": "1000 lbf.ft",
+    "M": "m",
+    "M3M2": "m",
+    "METER": "m",
+    "METERS": "m",
+    "METRE": "m",
+    "METRES": "m",
+    "Meter": "m",
+    "m3/m2": "m",
+    "meter": "m",
+    "metres": "m",
+    "м": "m",
+    "deg/100ft": "0.01 dega/ft",
+    "dega/100ft": "0.01 dega/ft",
+    "0.01 deg/ft": "0.01 dega/ft",
+    "feet": "ft",
+    "FT": "ft",
+    "foot": "ft",
+    "FT/S": "ft/s",
+    "ft/ht": "ft/h",
+    "F/HR": "ft/h",
+    "f/hr": "ft/h",
+    "FT/H": "ft/h",
+    "ft/hr": "ft/h",
+    "FT/HR": "ft/h",
+    "m/hr": "m/h",
+    "M/HR": "m/h",
+    "1/30 deg/m": "1/30 dega/m",
+    "deg/30m": "1/30 dega/m",
+    "deg/m": "dega/m",
+    "1000 ft.lbf": "1000 lbf.ft",
+    "1000ft.lbf": "1000 lbf.ft",
+    "1000 lbf": "klbf",
+    "1000lbf": "klbf",
+    "1000 lbm": "klbm",
+    "kkgf": "Mgf",
+    "ppg": "lbm/gal[US]",
+    "LB/G": "lbm/gal[US]",
+    "lb/gal": "lbm/gal[US]",
+    "LBM/GAL": "lbm/gal[US]",
+    "PPA": "lbm/gal[US]",
+    "PPG": "lbm/gal[US]",
+    "PPGE": "lbm/gal[US]",
+    "lb/U.S.gal": "lbm/gal[US]",
+    "lbm/galUS": "lbm/gal[US]",
+    "1000 kgf": "Mgf",
+    "KKGF": "Mgf",
+    "v": "V",
+    "VOLT": "V",
+    "Volts": "V",
+    "volts": "V",
+    "В": "V",
+    "Mv": "MV",
+    "DEGC": "degC",
+    "Cel": "degC",
+    "DEG C": "degC",
+    "DEG_C": "degC",
+    "DEGc": "degC",
+    "DegC": "degC",
+    "deg C": "degC",
+    "oC": "degC",
+    "lpm": "L/min",
+    "л/мин": "L/min",
+    "°C": "degC",
+    "DEGF": "degF",
+    "DegF": "degF",
+    "deg F": "degF",
+    "oF": "degF",
+    "°F": "degF",
+    "RPM": "rpm",
+    "KLBF": "klbf",
+    "KFLB": "klbf",
+    "G": "gn",
+    "G's": "gn",
+    "hr": "h",
+    "hour": "h",
+    "HR": "h",
+    "hrs": "h",
+    "MINUTES": "min",
+    "MIN": "min",
+    "MINUTE": "min",
+    "mins": "min",
+    "мин": "min",
+    "PSI": "psi",
+    "APSI": "psi",
+    "PSIA": "psi",
+    "psia": "psi",
+    "KPSI": "kpsi",
+    "ft.lbf": "lbf.ft",
+    "in.lbf": "lbf.in",
+    "FLBF": "lbf.in",
+    "ft-lbs": "lbf.in",
+    "pa": "Pa",
+    "PA": "Pa",
+    "IN": "in",
+    "db": "dB",
+    "дБ": "dB",
+    "kpa": "kPa",
+    "KPA": "kPa",
+    "1000 Pa": "kPa",
+    "KPAA": "kPa",
+    "kN/m2": "kPa",
+    "kPaa": "kPa",
+    "кПа": "kPa",
+    "GAPI": "gAPI",
+    "OHMM": "ohm.m",
+    "kdan": "10 kN",
+    "kdaN": "10 kN",
+    "KDAN": "10 kN",
+    "HZ": "Hz",
+    "pu": "%",
+    "PU": "%",
+    "PERC": "%",
+    "PCNT": "%",
+    "PERCENTAGE": "%",
+    "IN2": "in2",
+    "LB": "lbf",
+    "LBF": "lbf",
+    "LBS": "lbf",
+    "lbs": "lbf",
+    "kg/(m.s2)": "Pa",
+    "AHrs": "A.h",
+    "amp-hours": "A.h",
+    "degreesCelsius": "degC",
+    "KNM": "kN.m",
+    "KGM3": "kg/m3",
+    "KDN": "kdyne",
+    "RPG": "rev/gal[US]",
+    "0.01 m3/m3": "0.01 bbl/bbl",
+    "0.001/(ohm.m)": "mS",
 }
 
 
diff --git a/uom/uom.py b/uom/uom.py
index 8f324e9..36a94ab 100644
--- a/uom/uom.py
+++ b/uom/uom.py
@@ -11,20 +11,20 @@ def base_conversion_factors(unit_or_alias, verbose=False):
 
     if unit not in DF_UOM.index:
         if verbose:
-            print(f'Unit {unit_or_alias} unknown.')
+            print(f"Unit {unit_or_alias} unknown.")
 
         return None, None, None
 
     if verbose:
-        print(unit, DF_UOM['A'][unit], DF_UOM['B'][unit], DF_UOM['C'][unit])
+        print(unit, DF_UOM["A"][unit], DF_UOM["B"][unit], DF_UOM["C"][unit])
 
-    if DF_UOM['baseUnit'][unit] == 'IS-BASE':
+    if DF_UOM["baseUnit"][unit] == "IS-BASE":
         if verbose:
-            print('The unit {unit} it is a base unit.')
+            print(f"The unit {unit} it is a base unit.")
 
         return 0, 1, 1
 
-    return DF_UOM['A'][unit], DF_UOM['B'][unit], DF_UOM['C'][unit]
+    return DF_UOM["A"][unit], DF_UOM["B"][unit], DF_UOM["C"][unit]
 
 
 def base_unit(unit_or_alias, verbose=False):
@@ -33,48 +33,54 @@ def base_unit(unit_or_alias, verbose=False):
 
     if unit not in DF_UOM.index:
         if verbose:
-            print(f'Unit {unit_or_alias} unknown.')
+            print(f"Unit {unit_or_alias} unknown.")
 
         return None
 
-    b_unit = DF_UOM['baseUnit'][unit]
-    underlying_def = DF_UOM['underlyingDef'][unit]
+    b_unit = DF_UOM["baseUnit"][unit]
+    underlying_def = DF_UOM["underlyingDef"][unit]
 
     if verbose:
-        print(f'Input: {unit_or_alias}, unit: {unit}, base_unit: {b_unit}, underlying_unit: '
-              f'{underlying_def}')
+        print(
+            f"Input: {unit_or_alias}, unit: {unit}, base_unit: {b_unit}, underlying_unit: "
+            f"{underlying_def}"
+        )
 
-    if b_unit == 'IS-BASE':
+    if b_unit == "IS-BASE":
         if underlying_def:
             if underlying_def not in DF_UOM.index:
                 if verbose:
-                    print(f'{unit_or_alias} => {unit} [Case1: IsBase, UD = {underlying_def}, '
-                          'but not available]>')
+                    print(
+                        f"{unit_or_alias} => {unit} [Case1: IsBase, UD = {underlying_def}, "
+                        "but not available]>"
+                    )
 
                 return unit
 
             if verbose:
-                print(f'{unit_or_alias} => {unit} [Case2: IsBase, UD = {underlying_def} and '
-                      'available]')
+                print(
+                    f"{unit_or_alias} => {unit} [Case2: IsBase, UD = {underlying_def} and "
+                    "available]"
+                )
 
-            unit2 = DF_UOM['baseUnit'][underlying_def]
+            unit2 = DF_UOM["baseUnit"][underlying_def]
 
             if unit2 not in DF_UOM.index:
                 if verbose:
-                    print(f'Base unit {unit2} not in the index')
+                    print(f"Base unit {unit2} not in the index")
 
                 return underlying_def
 
             if verbose:
-                print(f'Base unit {b_unit} in the index')
+                print(f"Base unit {b_unit} in the index")
         else:
             if verbose:
-                print(f'{unit_or_alias} => {unit} [Case3: IsBase, UD is missing]')
+                print(f"{unit_or_alias} => {unit} [Case3: IsBase, UD is missing]")
 
             return unit
 
     if verbose:
-        print(f'{unit_or_alias} => {b_unit} [Case4: IsNotBase available]')
+        print(f"{unit_or_alias} => {b_unit} [Case4: IsNotBase available]")
 
     return base_unit(b_unit, verbose)
 
@@ -89,13 +95,15 @@ def conversion_factors(source, target, verbose=False):
 
     if source_base_unit != target_base_unit:
         if verbose:
-            print(f'The units {source} and {target} are not compatible.')
+            print(f"The units {source} and {target} are not compatible.")
 
-        source_dim = DF_UOM['dimension'][unit_alias(source)]
+        source_dim = DF_UOM["dimension"][unit_alias(source)]
 
-        if source_dim == DF_UOM['dimension'][unit_alias(target)] and \
-           source_dim != 'none':
-            raise Exception('ERROR: Houston, we have a problem')
+        if (
+            source_dim == DF_UOM["dimension"][unit_alias(target)]
+            and source_dim != "none"
+        ):
+            raise Exception("ERROR: Houston, we have a problem")
 
         return None, None
 
@@ -106,15 +114,14 @@ def conversion_factors(source, target, verbose=False):
     offset = source_a * target_c / source_c / target_b - target_a / target_b
 
     if verbose:
-        print(f'Scale: {scale}, offset: {offset}')
+        print(f"Scale: {scale}, offset: {offset}")
 
     return scale, offset
 
 
 def convert(value, source=None, target=None, verbose=False):
     """Convert value(s) from source to target."""
-    if source == target or \
-            ('unitless' in [source, target] and '' in [source, target]):
+    if source == target or ("unitless" in [source, target] and "" in [source, target]):
         return value
 
     if target is None and source is not None:
diff --git a/uom/uomdata.py b/uom/uomdata.py
index 9f33fa3..e561c4c 100644
--- a/uom/uomdata.py
+++ b/uom/uomdata.py
@@ -5,4 +5,4 @@
 
 from pandas import read_csv
 
-DF_UOM = read_csv(resource_filename('uom', 'uom.csv'), index_col=0)
+DF_UOM = read_csv(resource_filename("uom", "uom.csv"), index_col=0)