PyAutomationIO 1.1.1__py3-none-any.whl

automation/variables/mass_flow.py

@@ -0,0 +1,101 @@
+from ..utils.units import *
+
+class MassFlow(EngUnit):
+    """Creates a mass flow object that can store a mass flow value and 
+    convert between units of mass flow.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [MassFlow Object]\n
+
+    ```python
+    >>> from automation.variables.mass_flow import MassFlow
+    >>> mass_flow = MassFlow(value=1.0, unit="kg/hr")
+    >>> mass_flow.value
+    1.0
+    >>> mass_flow.unit
+    'kg/hr'
+    >>> mass_flow.convert(to_unit="lb/sec")
+    0.0006123951727222222
+    >>> MassFlow.convert_value(value=1.0, from_unit="kg/hr", to_unit="lb/sec")
+    0.0006123951727222222
+    >>> MassFlow.convert_values(values=[1.0, 10.0], from_unit="kg/hr", to_unit="lb/sec")
+    [0.0006123951727222222, 0.0061239517272222216]
+    >>> mass_flow.change_unit(unit="lb/sec")
+    0.0006123951727222222
+    >>> mass_flow.unit
+    'lb/sec'
+    >>> mass_flow.get_value()
+    [0.0006123951727222222, 'lb/sec']
+    >>> print(mass_flow)
+    0.0006123951727222222 lb/sec
+    >>> mass_flow2 = MassFlow(value=3.0, unit="lb/sec")
+    >>> mass_flow_result = mass_flow + mass_flow2
+    >>> print(mass_flow_result)
+    3.0006123951727224 lb/sec
+    >>> mass_flow_result = mass_flow * mass_flow2
+    >>> print(mass_flow_result)
+    0.0018371855181666666 lb/sec
+    >>> mass_flow_result = mass_flow / mass_flow2
+    >>> print(mass_flow_result)
+    0.00020413172424074073 lb/sec
+    >>> mass_flow_result = mass_flow ** mass_flow2
+    >>> print(mass_flow_result)
+    2.2966524349040475e-10 lb/sec
+
+    ```
+
+    """
+    
+    class Units(UnitSerializer):
+        kg_day = 'kg/day'
+        kg_hr = 'kg/hr'
+        kg_min = 'kg/min'
+        kg_sec = 'kg/sec'
+        g_day = 'g/day'
+        g_hr = 'g/hr'
+        g_min = 'g/min'
+        g_sec = 'g/sec'
+        mg_day = 'mg/day'
+        mg_hr = 'mg/hr'
+        mg_min = 'mg/min'
+        mg_sec = 'mg/sec'
+        lb_day = 'lb/day'
+        lb_hr = 'lb/hr'
+        lb_min = 'lb/min'
+        lb_sec = 'lb/sec'
+        metricTon_day = 'metricTon/day'
+        metricTon_hr = 'metricTon/hr'
+        metricTon_min = 'metricTon/min'
+        metricTon_sec = 'metricTon/sec'
+    
+    conversions = {
+        'kg/day' : 1.0,
+        'kg/hr' : 1.0 / 24,
+        'kg/min' : 1.0 / 24 / 60,
+        'kg/sec' : 1.0 / 24 / 60 / 60,
+        'g/day' : 1000.0,
+        'g/hr' : 1000.0 / 24,
+        'g/min' : 1000.0 / 24 / 60,
+        'g/sec' : 1000.0 / 24 / 60 / 60,
+        'mg/day' : 1000000.0,
+        'mg/hr' : 1000000.0 / 24,
+        'mg/min' : 1000000.0 / 24 / 60,
+        'mg/min' : 1000000.0 / 24 / 60 / 60,
+        'metricTon/day' : 1.0 / 1000.0,
+        'metricTon/hr' : 1.0 / 1000.0 / 24,
+        'metricTon/min' : 1.0 / 1000.0 / 24 / 60,
+        'metricTon/sec' : 1.0 / 1000.0 / 24 / 60 / 60,
+        'lb/day' : 2.2046226218,
+        'lb/hr' : 2.2046226218 / 24,
+        'lb/min' : 2.2046226218 / 24 / 60,
+        'lb/sec' : 2.2046226218 / 24 / 60 / 60
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in MassFlow.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {MassFlow.Units.list()}")
+        
+        super(MassFlow, self).__init__(value=value, unit=unit)

automation/variables/percentage.py

@@ -0,0 +1,30 @@
+from ..utils.units import EngUnit, UnitSerializer, UnitError
+
+class Percentage(EngUnit):
+    """Creates a percentage object that can store a percentage value and 
+    convert between units of percentage.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Length Object]\n
+
+    
+    ```
+    """
+    
+    class Units(UnitSerializer):
+        percentage = '%' 
+
+
+    conversions = {
+
+        '%' : 1.0
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Percentage.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Percentage.Units.list()}")
+        
+        super(Percentage, self).__init__(value=value, unit=unit)

automation/variables/power.py

@@ -0,0 +1,113 @@
+from ..utils.units import *
+
+class Power(EngUnit):
+    """Creates a power object that can store a power value and 
+    convert between units of power.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Power Object]\n
+
+    ```python
+    >>> from automation.variables.power import Power
+    >>> power = Power(value=1.0, unit="BTU/hr")
+    >>> power.value
+    1.0
+    >>> power.unit
+    'BTU/hr'
+    >>> power.convert(to_unit="mW")
+    293.0712104427134
+    >>> Power.convert_value(value=1.0, from_unit="BTU/hr", to_unit="kCal/sec")
+    7.03370905062512e-05
+    >>> Power.convert_values(values=[1.0, 10.0], from_unit="BTU/hr", to_unit="kCal/sec")
+    [7.03370905062512e-05, 0.0007033709050625121]
+    >>> power.change_unit(unit="mW")
+    293.0712104427134
+    >>> power.unit
+    'mW'
+    >>> power.get_value()
+    [293.0712104427134, 'mW']
+    >>> print(power)
+    293.0712104427134 mW
+    >>> power2 = Power(value=3.0, unit="kCal/sec")
+    >>> power_result = power + power2
+    >>> print(power_result)
+    12500293.071210442 mW
+    >>> power_result = power * power2
+    >>> print(power_result)
+    3663390130.5339174 mW
+    >>> power_result = power / power2
+    >>> print(power_result)
+    2.344569683541707e-05 mW
+
+    ```
+    """
+
+    class Units(UnitSerializer):
+        kW = 'kW'
+        BTU_hr = 'BTU/hr'
+        BTU_min = 'BTU/min'
+        BTU_sec = 'BTU/sec'
+        cal_sec = 'cal/sec'
+        cal_min = 'cal/min'
+        cal_hr = 'cal/hr'
+        erg_sec = 'erg/sec'
+        erg_min = 'erg/min'
+        erg_hr = 'erg/hr'
+        ftlb_sec = 'ftlb/sec'
+        GW = 'GW'
+        MW = 'MW'
+        kCal_sec = 'kCal/sec'
+        kCal_min = 'kCal/min'
+        kCal_hr = 'kCal/hr'
+        mW = 'mW'
+        W = 'W'
+        VA = 'VA'
+        hp_mech = 'hp_mech'
+        hp_ele = 'hp_ele'
+        hp_metric = 'hp_metric'
+        metric_ton_ref = 'metric_ton_ref'
+        US_ton_ref = 'US_ton_ref'
+        J_sec = 'J/sec'
+        J_min = 'J/min'
+        J_hr = 'J/hr'
+        kgfm_sec = 'kgf-m/sec'
+
+    conversions = {
+        'kW' : 1.0,
+        'BTU/hr' : 3412.14,
+        'BTU/min' : 56.869,
+        'BTU/sec' : 0.94781666666,
+        'cal/sec' : 238.85,
+        'cal/min' : 238.85 * 60,
+        'cal/hr' : 238.85 * 60 * 60,
+        'erg/sec' : 10e9,
+        'erg/min' : 10e9 * 60,
+        'erg/hr' : 10e9 * 60 * 60,
+        'ftlb/sec' : 737.56,
+        'GW' : 1e-6,
+        'MW' : 1e-3,
+        'kCal/sec' : 0.24,
+        'kCal/min' : 0.24 * 60,
+        'kCal/hr' : 0.24 * 60 * 60,
+        'mW' : 1e6,
+        'W' : 1e3,
+        'VA' : 1e3,
+        'hp_mech' : 1.3410220888,
+        'hp_ele' : 1.3404825737,
+        'hp_metric' : 1.359621617304,
+        'metric_ton_ref' : 0.259,
+        'US_ton_ref' : 0.2843451361,
+        'J/sec' : 1000.0,
+        'J/min' : 1000.0 * 60,
+        'J/hr' : 1000.0 * 60 * 60,
+        'kgf-m/sec' : 101.97162129779
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Power.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Power.Units.list()}")
+        
+        super(Power, self).__init__(value=value, unit=unit)

automation/variables/pressure.py

@@ -0,0 +1,93 @@
+from ..utils.units import *
+
+class Pressure(EngUnit):
+    """Creates a pressure object that can store a pressure value and 
+    convert between units of pressure.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Pressure Object]\n
+
+    ```python
+    >>> from automation.variables.pressure import Pressure
+    >>> pressure = Pressure(value=1.0, unit="atm")
+    >>> pressure.value
+    1.0
+    >>> pressure.unit
+    'atm'
+    >>> pressure.convert(to_unit="psi")
+    14.695979321588414
+    >>> Pressure.convert_value(value=1.0, from_unit="atm", to_unit="bar")
+    1.0132502738308866
+    >>> Pressure.convert_values(values=[1.0, 10.0], from_unit="atm", to_unit="bar")
+    [1.0132502738308866, 10.132502738308865]
+    >>> pressure.change_unit(unit="psi")
+    14.695979321588414
+    >>> pressure.unit
+    'psi'
+    >>> pressure.get_value()
+    [14.695979321588414, 'psi']
+    >>> print(pressure)
+    14.695979321588414 psi
+    >>> pressure2 = Pressure(value=3.0, unit="bar")
+    >>> pressure_result = pressure + pressure2
+    >>> print(pressure_result)
+    58.20737932158842 psi
+    >>> pressure_result = pressure * pressure2
+    >>> print(pressure_result)
+    639.4426346533621 psi
+    >>> pressure_result = pressure / pressure2
+    >>> print(pressure_result)
+    0.3377500912769622 psi
+    >>> pressure_result = pressure ** pressure2
+    >>> print(pressure_result)
+    6.115644251483115e+50 psi
+
+    ```
+
+    """
+    
+    class Units(UnitSerializer):
+        bar = 'bar' 
+        mbar = 'mbar' 
+        ubar = 'ubar' 
+        Pa = 'Pa' 
+        hPa = 'hPa' 
+        kPa = 'kPa' 
+        MPa = 'MPa' 
+        kgcm2 = 'kgcm2' 
+        atm = 'atm' 
+        mmHg = 'mmHg' 
+        mmH2O = 'mmH2O' 
+        mH2O = 'mH2O' 
+        psi = 'psi' 
+        ftH2O = 'ftH2O' 
+        inH2O = 'inH2O' 
+        inHg = 'inHg' 
+    
+    conversions = {
+        'bar' : 1.0,
+        'mbar' : 1000.0,
+        'ubar' : 1000000.0,
+        'Pa' : 100000.0,
+        'hPa' : 1000.0,
+        'kPa' : 100.0,
+        'MPa' : 0.1,
+        'kgcm2' : 1.01972,
+        'atm' : 0.986923,
+        'mmHg' : 750.062,
+        'mmH2O' : 10197.162129779,
+        'mH2O' : 10.197162129779,
+        'psi' : 14.5038,
+        'ftH2O' : 33.455256555148,
+        'inH2O' : 401.865,
+        'inHg' : 29.53
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Pressure.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Pressure.Units.list()}")
+        
+        super(Pressure, self).__init__(value=value, unit=unit)

automation/variables/temperature.py

@@ -0,0 +1,168 @@
+from ..utils.units import EngUnit, UnitSerializer, UnitError
+
+class Temperature(EngUnit):
+    """Creates a temperature object that can store a temperature value and 
+    convert between units of temperature.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Temperature Object]\n
+
+    ```python
+    >>> from automation.variables.temperature import Temperature
+    >>> temperature = Temperature(value=25, unit="C")
+    >>> temperature.value
+    25
+    >>> temperature.unit
+    'C'
+    >>> temperature.convert(to_unit="F")
+    76.99999999999994
+    >>> Temperature.convert_value(value=1.0, from_unit="C", to_unit="K")
+    274.15
+    >>> temperature.change_unit(unit="F")
+    76.99999999999994
+    >>> temperature.unit
+    'F'
+    >>> temperature.get_value()
+    [76.99999999999994, 'F']
+    >>> print(temperature)
+    76.99999999999994 F
+    >>> temperature2 = Temperature(value=3.0, unit="K")
+    >>> temperature_result = temperature + temperature2
+    >>> print(temperature_result)
+    82.39999999999992 F
+    >>> temperature_result = temperature * temperature2
+    >>> print(temperature_result)
+    894.4499999999999 K
+    >>> temperature_result = temperature / temperature2
+    >>> print(temperature_result)
+    99.38333333333333 K
+    >>> temperature_result = temperature ** temperature2
+    >>> print(temperature_result)
+    26503573.918374993 K
+
+    ```
+    """
+    
+    class Units(UnitSerializer):
+        degKelvin = 'K'
+        degCelsius = 'C'
+        degRankine = 'R'
+        degFarenheit = 'F'
+
+    # conversions { } is not used to convert the Temperature() class because 
+    # temperature is not converted with a scalar.  See the convert() function below.
+    conversions = {
+        'K' : 1.0,
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Temperature.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Temperature.Units.list()}")
+        
+        super(Temperature, self).__init__(value=value, unit=unit)
+
+    def convert(self, to_unit):
+        """
+        Converts a temperature value from one unit of measure to another.
+        Returns a float value of the temperature in requested units. 
+        Returns None for incorrect value.
+
+        Units of Measure
+        ---------------
+        Units of measure entered as a string.
+        'K' - Degree Kelvin\n
+        'F' - Degree Farenheit\n
+        'R' - Degree Rankine\n
+        'C' - Degree Celcius
+
+        Parameters
+        ---------------
+        value : float
+            Value of the temperature measurement.\n
+        from_unit : str
+            Unit of measurement to convert from.\n
+        to_unit : str
+            Unit of measurement to convert to.
+        """
+    
+        temperature_kelvin = 0
+        if self.unit.upper() == 'K':
+            temperature_kelvin = self.value
+        elif self.unit == 'R':
+            temperature_kelvin = self.value * 5.0 / 9.0
+        elif self.unit == 'C':
+            temperature_kelvin = self.value + 273.15
+        elif self.unit == 'F':
+            temperature_kelvin = (self.value + 459.67) / 9.0 * 5.0
+        else:
+            return None
+        
+        # Return Value in Required Unit
+        if to_unit == 'K':
+            return float(temperature_kelvin)
+        elif to_unit == 'R':
+            return temperature_kelvin * 9.0 / 5.0
+        elif to_unit == 'C':
+            return temperature_kelvin - 273.15
+        elif to_unit == 'F':
+            return temperature_kelvin * 9.0 / 5.0 - 459.67
+        else:
+            return None  
+
+    @classmethod
+    def convert_value(cls, value, from_unit:str, to_unit:str):
+        
+        temperature_kelvin = 0
+        if from_unit.upper() == 'K':
+            temperature_kelvin = value
+        elif from_unit.upper() == 'R':
+            temperature_kelvin = value * 5.0 / 9.0
+        elif from_unit.upper() == 'C':
+            temperature_kelvin = value + 273.15
+        elif from_unit.upper() == 'F':
+            temperature_kelvin = (value + 459.67) / 9.0 * 5.0
+        else:
+            return None
+        
+        # Return Value in Required Unit
+        if to_unit == 'K':
+            return float(temperature_kelvin)
+        elif to_unit == 'R':
+            return temperature_kelvin * 9.0 / 5.0
+        elif to_unit == 'C':
+            return temperature_kelvin - 273.15
+        elif to_unit == 'F':
+            return temperature_kelvin * 9.0 / 5.0 - 459.67
+        else:
+            return None  
+
+    def __add__(self, other):
+        self_original_unit = self.unit
+
+        self.change_unit('K')
+
+        if other.unit in ('K', 'C'):
+            new_value = self.value + other.value
+        else:
+            new_value = self.value + (other.value * 5.0 / 9.0)            
+
+        new_unit = self.__class__(new_value, 'K')
+        new_unit.change_unit(self_original_unit)
+        return new_unit
+
+    def __sub__(self, other):
+            self_original_unit = self.unit
+
+            self.change_unit('K')
+
+            if other.unit in ('K', 'C'):
+                new_value = self.value - other.value
+            else:
+                new_value = self.value - (other.value * 5.0 / 9.0)            
+
+            new_unit = self.__class__(new_value, 'K')
+            new_unit.change_unit(self_original_unit)
+            return new_unit

automation/variables/volume.py

@@ -0,0 +1,70 @@
+from ..utils.units import *
+
+class Volume(EngUnit):
+    """Creates a flow object that can store a flow value and 
+    convert between units of flow.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Volume Object]\n
+
+    ```python
+    >>> from automation.variables.volume import Volume
+    >>> volume = Volume(value=1.0, unit="bbl")
+    >>> volume.value
+    1.0
+    >>> volume.unit
+    'bbl'
+    >>> volume.convert(to_unit="m3")
+    0.158987294928
+    >>> Volume.convert_value(value=1.0, from_unit="gal", to_unit="bbl")
+    0.023809523809523808
+    >>> Volume.convert_values(values=[1.0, 10.0], from_unit="gal", to_unit="bbl")
+    [0.023809523809523808, 0.23809523809523808]
+    >>> volume.change_unit(unit="gal")
+    42.0
+    >>> volume.unit
+    'gal'
+    >>> volume.get_value()
+    [42.0, 'gal']
+    >>> print(volume)
+    42.0 gal
+    >>> volume2 = Volume(value=120.0, unit="lt")
+    >>> volume_result = volume + volume2
+    >>> print(volume_result)
+    73.7006462829778 gal
+    >>> volume_result = volume * volume2
+    >>> print(volume_result)
+    1331.4271438850678 gal
+    >>> volume_result = volume / volume2
+    >>> print(volume_result)
+    1.3248941244 gal
+    >>> volume_result = volume ** volume2
+    >>> print(volume_result)
+    2.8711215836780378e+51 gal
+
+    ```
+    """
+
+    class Units(UnitSerializer):
+        bbl = 'bbl'
+        gal = 'gal'
+        cubic_meter = 'm3'
+        liter_sec = 'lt'
+        milliliter = 'ml'
+
+    conversions = {
+        'bbl' : 1.0,
+        'gal' : 42.0,
+        'm3' : 0.158987294928,
+        'lt' : 158.987294928,
+        'ml' : 158987.294928
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Volume.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Volume.Units.list()}")
+        
+        super(Volume, self).__init__(value=value, unit=unit)

automation/variables/volumetric_flow.py

@@ -0,0 +1,100 @@
+from ..utils.units import *
+
+class VolumetricFlow(EngUnit):
+    """Creates a flow object that can store a flow value and 
+    convert between units of flow.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [VolumetricFlow Object]\n
+
+    ```python
+    >>> from automation.variables.volumetric_flow import VolumetricFlow
+    >>> volumetric_flow = VolumetricFlow(value=1.0, unit="bbl/sec")
+    >>> volumetric_flow.value
+    1.0
+    >>> volumetric_flow.unit
+    'bbl/sec'
+    >>> volumetric_flow.convert(to_unit="m3/day")
+    13736.5022817792
+    >>> VolumetricFlow.convert_value(value=1.0, from_unit="gal/sec", to_unit="bbl/sec")
+    0.023809523809523808
+    >>> VolumetricFlow.convert_values(values=[1.0, 10.0], from_unit="gal/sec", to_unit="bbl/sec")
+    [0.023809523809523808, 0.23809523809523808]
+    >>> volumetric_flow.change_unit(unit="gal/sec")
+    42.0
+    >>> volumetric_flow.unit
+    'gal/sec'
+    >>> volumetric_flow.get_value()
+    [42.0, 'gal/sec']
+    >>> print(volumetric_flow)
+    42.0 gal/sec
+    >>> volumetric_flow2 = VolumetricFlow(value=120.0, unit="gal/min")
+    >>> volumetric_flow_result = volumetric_flow + volumetric_flow2
+    >>> print(volumetric_flow_result)
+    44.0 gal/sec
+    >>> volumetric_flow_result = volumetric_flow * volumetric_flow2
+    >>> print(volumetric_flow_result)
+    84.0 gal/sec
+    >>> volumetric_flow_result = volumetric_flow / volumetric_flow2
+    >>> print(volumetric_flow_result)
+    21.0 gal/sec
+    >>> volumetric_flow_result = volumetric_flow ** volumetric_flow2
+    >>> print(volumetric_flow_result)
+    1764.0 gal/sec
+
+    ```
+    """
+
+    class Units(UnitSerializer):
+        bbl_day = 'bbl/day'
+        bbl_hr = 'bbl/hr'
+        bbl_min = 'bbl/min'
+        bbl_sec = 'bbl/sec'
+        gal_day = 'gal/day'
+        gal_hr = 'gal/hr'
+        gal_min = 'gal/min'
+        gal_sec = 'gal/sec'
+        cubic_meter_day = 'm3/day'
+        cubic_meter_hr = 'm3/hr'
+        cubic_meter_min = 'm3/min'
+        cubic_meter_sec = 'm3/sec'
+        liter_day = 'lt/day'
+        liter_hr = 'lt/hr'
+        liter_min = 'lt/min'
+        liter_sec = 'lt/sec'
+        cubic_centimeter_day = 'cc/day'
+        cubic_centimeter_hr = 'cc/hr'
+        cubic_centimeter_min = 'cc/min'
+        cubic_centimeter_sec = 'cc/sec'
+
+    conversions = {
+        'bbl/day' : 1.0 * 60.0 * 60.0 * 24.0,
+        'bbl/hr' : 1.0 * 60 * 60,
+        'bbl/min' : 1.0 * 60.0,
+        'bbl/sec' : 1.0,
+        'gal/day' : 42.0 * 60.0 * 60.0 * 24.0,
+        'gal/hr' : 42.0 * 60.0 * 60.0,
+        'gal/min' : 42.0 * 60.0,
+        'gal/sec' : 42.0,
+        'm3/day' : 0.158987294928 * 60 * 60 * 24,
+        'm3/hr' : 0.158987294928 * 60 * 60,
+        'm3/min' : 0.158987294928 * 60,
+        'm3/sec' : 0.158987294928,
+        'lt/day' : 158.987294928 * 60 * 60 * 24,
+        'lt/hr' : 158.987294928 * 60 * 60,
+        'lt/min' : 158.987294928 * 60,
+        'lt/sec' : 158.987294928,
+        'ml/day' : 158987.294928 * 60 * 60 * 24,
+        'ml/hr' : 158987.294928 * 60 * 60,
+        'ml/min' : 158987.294928 * 60,
+        'ml/sec' : 158987.294928
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in VolumetricFlow.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {VolumetricFlow.Units.list()}")
+        
+        super(VolumetricFlow, self).__init__(value=value, unit=unit)

automation/workers/__init__.py

@@ -0,0 +1,2 @@
+from .state_machine import StateMachineWorker, AsyncStateMachineWorker
+from .logger import LoggerWorker