corva-unit-converter 0.1.0__tar.gz

corva-unit-converter-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.1
+Name: corva-unit-converter
+Version: 0.1.0
+Summary: Unit converter for O&G(and other) units
+Home-page: https://github.com/corva-ai/corva-convert-units-py
+Author: Yuliya Klimushina
+Author-email: yuliya.klimushina@corva.ai
+License: MIT
+Keywords: corva,unit converter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8, <4.0
+Description-Content-Type: text/markdown
+
+# Units Converter
+
+Library for converting between quantities in different units(including units specific to O&G).
+
+This is a python version of the existing javascript app.
+Credit goes to the creator and contributors of the original version https://github.com/corva-ai/corva-convert-units,
+which is a fork of https://github.com/convert-units/convert-units.
+
+# Installation
+
+```shell
+pip install corva-unit-converter
+```
+
+# Usage:
+
+Imperial to metric:
+
+    from corva_unit_converter.converter import Converter
+    converter = Converter()
+    length_meters = converter.convert(unit_from="ft", unit_to="m", value=1)
+
+Metric to imperial:
+
+    from corva_unit_converter.converter import Converter
+    converter = Converter()
+    torque_ft_lbf = converter.convert(unit_from="Nm", unit_to="ft-lbf", value=1)
+
+Metric to metric:
+
+    from corva_unit_converter.converter import Converter
+    converter = Converter()
+    mass_grams = converter.convert(unit_from="kg", unit_to="g", value=1)
+
+
+# Testing
+
+1. Create virtualenv via your favourite tool, for example 
+```shell
+python3 -m venv venv
+source venv/bin/activate
+```
+2. Install all requirements:
+```shell
+pip install -r requirements.txt && pip install -r requirements-test.txt
+```
+3. Run tests with coverage:
+```shell
+make coverage
+```
+or tests without coverage:
+```shell
+make test
+```
+Linters are available through
+```shell
+make lint
+```
+
+# License
+This project is licensed under the terms of the MIT license.
+
+Copyright (c) 2013-2017 Ben Ng and Contributors, http://benng.me
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

corva-unit-converter-0.1.0/README.md

@@ -0,0 +1,69 @@
+# Units Converter
+
+Library for converting between quantities in different units(including units specific to O&G).
+
+This is a python version of the existing javascript app.
+Credit goes to the creator and contributors of the original version https://github.com/corva-ai/corva-convert-units,
+which is a fork of https://github.com/convert-units/convert-units.
+
+# Installation
+
+```shell
+pip install corva-unit-converter
+```
+
+# Usage:
+
+Imperial to metric:
+
+    from corva_unit_converter.converter import Converter
+    converter = Converter()
+    length_meters = converter.convert(unit_from="ft", unit_to="m", value=1)
+
+Metric to imperial:
+
+    from corva_unit_converter.converter import Converter
+    converter = Converter()
+    torque_ft_lbf = converter.convert(unit_from="Nm", unit_to="ft-lbf", value=1)
+
+Metric to metric:
+
+    from corva_unit_converter.converter import Converter
+    converter = Converter()
+    mass_grams = converter.convert(unit_from="kg", unit_to="g", value=1)
+
+
+# Testing
+
+1. Create virtualenv via your favourite tool, for example 
+```shell
+python3 -m venv venv
+source venv/bin/activate
+```
+2. Install all requirements:
+```shell
+pip install -r requirements.txt && pip install -r requirements-test.txt
+```
+3. Run tests with coverage:
+```shell
+make coverage
+```
+or tests without coverage:
+```shell
+make test
+```
+Linters are available through
+```shell
+make lint
+```
+
+# License
+This project is licensed under the terms of the MIT license.
+
+Copyright (c) 2013-2017 Ben Ng and Contributors, http://benng.me
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

corva-unit-converter-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=59.0", "wheel"]
+build-backend = "setuptools.build_meta"

corva-unit-converter-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

corva-unit-converter-0.1.0/setup.py

@@ -0,0 +1,40 @@
+import pathlib
+from importlib import machinery
+
+import setuptools
+
+ROOT = pathlib.Path(__file__).parent
+
+
+VERSION = str(
+    machinery.SourceFileLoader('version', 'src/version.py').load_module().VERSION
+)
+
+CLASSIFIERS = [
+    'Development Status :: 4 - Beta',
+    'Intended Audience :: Developers',
+    'Operating System :: OS Independent',
+    'Programming Language :: Python',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.8',
+    'Topic :: Software Development :: Libraries',
+]
+
+setuptools.setup(
+    name="corva-unit-converter",
+    author="Yuliya Klimushina",
+    author_email="yuliya.klimushina@corva.ai",
+    url="https://github.com/corva-ai/corva-convert-units-py",
+    version=VERSION,
+    classifiers=CLASSIFIERS,
+    description="Unit converter for O&G(and other) units",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    keywords="corva, unit converter",
+    py_modules=[file.stem for file in pathlib.Path("src").glob("*.py")],
+    packages=setuptools.find_packages("src"),
+    package_dir={"": "src"},
+    install_requires=[],
+    python_requires=">=3.8, <4.0",
+    license="MIT",
+)

corva-unit-converter-0.1.0/src/corva_unit_converter/constants.py

@@ -0,0 +1,2 @@
+# Earth gravity in m/s^2
+g = 9.80665

corva-unit-converter-0.1.0/src/corva_unit_converter/converter.py

@@ -0,0 +1,114 @@
+import logging
+from typing import Dict, Union
+
+from . import definitions
+
+measures = {
+    "acoustic_slowness": definitions.acoustic_slowness.rule,
+    "angle": definitions.angle.rule,
+    "angle_per_length": definitions.angle_per_length.rule,
+    "angular_velocity": definitions.angular_velocity.rule,
+    "area": definitions.area.rule,
+    "density": definitions.density.rule,
+    "energy": definitions.torque.rule,
+    "force": definitions.force.rule,
+    "gas_concentration": definitions.gas_concentration.rule,
+    "gas_volume": definitions.inverse_pressure.rule,
+    "inverse_pressure": definitions.gas_volume.rule,
+    "length": definitions.length.rule,
+    "length_per_angle": definitions.length_per_angle.rule,
+    "mass": definitions.mass.rule,
+    "mass_flow_rate": definitions.mass_flow_rate.rule,
+    "mpl": definitions.mpl.rule,
+    "porosity": definitions.porosity.rule,
+    "power": definitions.power.rule,
+    "pressure": definitions.pressure.rule,
+    "pressure_gradient": definitions.pressure_gradient.rule,
+    "revolution_per_volume": definitions.revolution_per_volume.rule,
+    "speed": definitions.speed.rule,
+    "temperature": definitions.temperature.rule,
+    "time": definitions.time.rule,
+    "torque": definitions.torque.rule,
+    "volume_concentration": definitions.volume_concentration.rule,
+    "volume_flow_rate": definitions.volume_flow_rate.rule,
+}
+
+
+def map_aliases_to_unit(measure, excluded_units):
+    return [{alias: unit} for unit in measure if unit not in excluded_units
+            for alias in measure[unit].get('aliases') or [unit]]
+
+
+def get_unit_for_alias(alias, measure):
+    mapping = map_aliases_to_unit(measure, [])
+    new_unit = [unit for item in mapping for key, unit in item.items() if key == alias]
+    return new_unit[0] if new_unit else None
+
+
+class Converter:
+    def __init__(self):
+        self.origin = {}
+        self.destination = {}
+
+    def get_unit_definition(self, source, unit):
+        definition = source.get(unit)
+        if not definition:
+            definition = self.get_unit(unit)
+            if not definition:
+                logging.info(f"{unit=} not found")
+                return
+        return definition
+
+    def convert(self, unit_from: str, unit_to: str,  # noqa: CCR001, CFQ004
+                value: Union[int, float]):
+        """Main function"""
+        origin = self.get_unit_definition(source=self.origin, unit=unit_from)
+        destination = self.get_unit_definition(source=self.destination, unit=unit_to)
+
+        if not origin or not destination:
+            return
+
+        # Don't change the value if origin and destination are the same
+        if origin["abbr"] == destination["abbr"]:
+            return value
+
+        # Convert from the source value to its anchor inside the system
+        result = value * origin["unit"]["to_anchor"]
+
+        # for some units it's a simple shift (e.g. C to K)
+        if "anchor_shift" in origin["unit"]:
+            result -= origin["unit"]["anchor_shift"]
+
+        # Convert from one system to another
+        if origin["system"] != destination["system"]:
+            # Convert through transformation
+            transform = measures[origin["measure"]]["_anchors"][origin["system"]].get("transform")
+            if transform and callable(transform):
+                result = transform(result)
+
+            # Convert through the anchor ratio
+            result *= measures[origin["measure"]]["_anchors"][origin["system"]]["ratio"]
+
+        # Apply shift after transformation for F to K
+        if "anchor_shift" in destination["unit"]:
+            result += destination["unit"]["anchor_shift"]
+
+        # Convert to another unit inside the destination system
+        return result / destination["unit"]["to_anchor"]
+
+    @staticmethod
+    def get_unit(abbr) -> Dict:  # noqa: CCR001
+        for measure, systems in measures.items():
+            for system, units in systems.items():
+                if system == "_anchors":
+                    break
+                new_abbr = get_unit_for_alias(abbr, units) or abbr
+                for test_abbr, unit in units.items():
+                    if test_abbr == new_abbr:
+                        return {
+                            "abbr": new_abbr,
+                            "measure": measure,
+                            "system": system,
+                            "unit": unit
+                        }
+        return {}

corva-unit-converter-0.1.0/src/corva_unit_converter/definitions/__init__.py

@@ -0,0 +1,69 @@
+from . import (
+    acoustic_slowness,
+    angle,
+    angle_per_length,
+    angular_velocity,
+    area,
+    current,
+    density,
+    digital,
+    energy,
+    force,
+    gas_concentration,
+    gas_volume,
+    inverse_pressure,
+    length,
+    length_per_angle,
+    mass,
+    mass_flow_rate,
+    mpl,
+    parts_per,
+    permiability,
+    porosity,
+    power,
+    pressure,
+    pressure_gradient,
+    revolution_per_volume,
+    speed,
+    temperature,
+    time,
+    torque,
+    voltage,
+    volume_concentration,
+    volume_flow_rate,
+)
+
+__all__ = [
+    "acoustic_slowness",
+    "angle",
+    "angle_per_length",
+    "angular_velocity",
+    "area",
+    "current",
+    "density",
+    "digital",
+    "energy",
+    "force",
+    "gas_concentration",
+    "gas_volume",
+    "inverse_pressure",
+    "length",
+    "length_per_angle",
+    "mass",
+    "mass_flow_rate",
+    "mpl",
+    "parts_per",
+    "permiability",
+    "porosity",
+    "power",
+    "pressure",
+    "pressure_gradient",
+    "revolution_per_volume",
+    "speed",
+    "temperature",
+    "time",
+    "torque",
+    "voltage",
+    "volume_concentration",
+    "volume_flow_rate"
+]

corva-unit-converter-0.1.0/src/corva_unit_converter/definitions/acoustic_slowness.py

@@ -0,0 +1,43 @@
+metric = {
+   "us/m": {
+      "name": {
+         "singular": "us/m",
+         "plural": "us/m",
+         "display": "us/m"
+      },
+      "to_anchor": 1,
+      "aliases": [
+         "us/m"
+      ]
+   }
+}
+
+imperial = {
+   "us/ft": {
+      "name": {
+         "singular": "us/ft",
+         "plural": "us/ft",
+         "display": "us/ft"
+      },
+      "to_anchor": 1,
+      "aliases": [
+         "us/f",
+         "us/ft"
+      ]
+   }
+}
+
+rule = {
+   "metric": metric,
+   "imperial": imperial,
+   "_anchors": {
+      "metric": {
+         "unit": "us/m",
+         "ratio": 1 / 3.28084
+      },
+      "imperial": {
+         "unit": "us/ft",
+         "ratio": 3.28084
+      }
+   }
+}

corva-unit-converter-0.1.0/src/corva_unit_converter/definitions/angle.py

@@ -0,0 +1,74 @@
+from math import pi
+
+angle = {
+   "rad": {
+      "name": {
+         "singular": "radian",
+         "plural": "radians",
+         "display": "rad"
+      },
+      "to_anchor": 180/pi,
+      "aliases": [
+         "rad"
+      ]
+   },
+   "deg": {
+      "name": {
+         "singular": "degree",
+         "plural": "degrees",
+         "display": "deg"
+      },
+      "to_anchor": 1,
+      "aliases": [
+         "deg"
+      ]
+   },
+   "grad": {
+      "name": {
+         "singular": "gradian",
+         "plural": "gradians",
+         "display": "grad"
+      },
+      "to_anchor": 9/10,
+      "aliases": [
+         "grad"
+      ]
+   },
+   "arcmin": {
+      "name": {
+         "singular": "arcminute",
+         "plural": "arcminutes",
+         "display": "acrmin"
+      },
+      "to_anchor": 1/60,
+      "aliases": [
+         "arcmin"
+      ]
+   },
+   "arcsec": {
+      "name": {
+         "singular": "arcsecond",
+         "plural": "arcseconds",
+         "display": "arcsec"
+      },
+      "to_anchor": 1/3600,
+      "aliases": [
+         "arcsec"
+      ]
+   }
+}
+
+rule = {
+   "metric": angle,
+   "imperial": angle,
+   "_anchors": {
+      "metric": {
+         "unit": "deg",
+         "ratio": 1
+      },
+      "imperial": {
+         "unit": "deg",
+         "ratio": 1
+      }
+   }
+}

corva-unit-converter-0.1.0/src/corva_unit_converter/definitions/angle_per_length.py

@@ -0,0 +1,64 @@
+metric = {
+   "dpm": {
+      "name": {
+         "singular": "degree per meter",
+         "plural": "degrees per meter",
+         "display": "°/m"
+      },
+      "to_anchor": 1,
+      "aliases": [
+         "dpm"
+      ]
+   },
+   "dp30m": {
+      "name": {
+         "singular": "degree per 30m",
+         "plural": "degrees per 30m",
+         "display": "°/30m"
+      },
+      "to_anchor": 1/30,
+      "aliases": [
+         "dp30m"
+      ]
+   }
+}
+
+imperial = {
+   "dpf": {
+      "name": {
+         "singular": "degree per foot",
+         "plural": "degrees per feet",
+         "display": "°/ft"
+      },
+      "to_anchor": 1,
+      "aliases": [
+         "dpf"
+      ]
+   },
+   "dp100f": {
+      "name": {
+         "singular": "degree per 100 foot",
+         "plural": "degrees per 100 feet",
+         "display": "°/100ft"
+      },
+      "to_anchor": 1/100,
+      "aliases": [
+         "dp100f"
+      ]
+   }
+}
+
+rule = {
+   "metric": metric,
+   "imperial": imperial,
+   "_anchors": {
+      "metric": {
+         "unit": "dpm",
+         "ratio": 1/3.28084
+      },
+      "imperial": {
+         "unit": "dpf",
+         "ratio": 3.28084
+      }
+   }
+}

corva-unit-converter-0.1.0/src/corva_unit_converter/definitions/angular_velocity.py

@@ -0,0 +1,110 @@
+# 1/s, rev/s, rpm, rph, rad/s, dega/s, dega/m, dega/h
+# NOTE: "a" letter is added to degree to avoid confusion with temperature
+#
+# to_anchor values might be clearer but the base unit was defined as RPM
+from math import pi
+
+metric = {
+    "1/s": {
+        "name": {
+            "singular": "revolution per second",
+            "plural": "revolutions per second",
+            "display": "1/s"
+        },
+        "to_anchor": 60,
+        "aliases": [
+            "1/s"
+        ]
+    },
+    "rev/s": {
+        "name": {
+            "singular": "revolution per second",
+            "plural": "revolutions per second",
+            "display": "1/s"
+        },
+        "to_anchor": 60,
+        "aliases": [
+            "rev/s"
+        ]
+    },
+    "rpm": {
+        "name": {
+            "singular": "revolution per minute",
+            "plural": "revolutions per minute",
+            "display": "rpm"
+        },
+        "to_anchor": 1,
+        "aliases": [
+            "rpm"
+        ]
+    },
+    "rph": {
+        "name": {
+            "singular": "revolution per hour",
+            "plural": "revolutions per hour",
+            "display": "rph"
+        },
+        "to_anchor": 1 / 60,
+        "aliases": [
+            "rph"
+        ]
+    },
+    "radsec": {
+        "name": {
+            "singular": "radian per second",
+            "plural": "radians per second",
+            "display": "rad/sec"
+        },
+        "to_anchor": 60 / (2 * pi),
+        "aliases": [
+            "radsec", "rad/s", "rad/sec"
+        ]
+    },
+    "dega/s": {
+        "name": {
+            "singular": "degree per second",
+            "plural": "degrees per second",
+            "display": "dega/s"
+        },
+        "to_anchor": 1 / 6,
+        "aliases": [
+            "dega/s"
+        ]
+    },
+    "dega/m": {
+        "name": {
+            "singular": "degree per minute",
+            "plural": "degrees per minute",
+            "display": "dega/m"
+        },
+        "to_anchor": 1 / 360,
+        "aliases": [
+            "dega/m"
+        ]
+    },
+    "dega/h": {
+        "name": {
+            "singular": "degree per hour",
+            "plural": "degrees per hour",
+            "display": "dega/h"
+        },
+        "to_anchor": (1 / 360) / 60,
+        "aliases": [
+            "dega/h"
+        ]
+    }
+}
+
+rule = {
+    "metric": metric,
+    "_anchors": {
+        "metric": {
+            "unit": "rpm",
+            "ratio": 1
+        },
+        "imperial": {
+            "unit": "rpm",
+            "ratio": 1
+        }
+    }
+}