PyAutomationIO 1.1.1__py3-none-any.whl

automation/variables/__init__.py

@@ -0,0 +1,55 @@
+from .temperature import Temperature
+from .length import Length
+from .current import Current
+from .eng_time import Time
+from .pressure import Pressure
+from .mass import Mass
+from .force import Force
+from .power import Power
+from .volumetric_flow import VolumetricFlow
+from .mass_flow import MassFlow
+from .density import Density
+from .percentage import Percentage
+from .adimentional import Adimentional
+from .volume import Volume
+
+
+temperature_base = Temperature(value=1, unit='K')
+length_base = Length(value=1, unit="m")
+current_base = Current(value=1, unit="A")
+time_base = Time(value=1, unit="s")
+pressure_base = Pressure(value=1, unit="bar")
+mass_base = Mass(value=1, unit="kg")
+force_base = Force(value=1, unit="J/m")
+power_base = Power(value=1, unit="kW")
+volumetric_flow_base = VolumetricFlow(value=1, unit="bbl/sec")
+mass_flow_base = MassFlow(value=1.0, unit="kg/day")
+density_base = Density(value=1.0, unit="kg/bbl")
+percentage_base = Percentage(value=0.0, unit="%")
+adimentional_base = Adimentional(value=0.0, unit="adim")
+volume_base = Volume(value=0.0, unit="m3")
+
+
+VARIABLES = {
+    f"{temperature_base.__class__.__name__}": temperature_base.Units.serialize(),
+    f"{length_base.__class__.__name__}": length_base.Units.serialize(),
+    f"{current_base.__class__.__name__}": current_base.Units.serialize(),
+    f"{time_base.__class__.__name__}": time_base.Units.serialize(),
+    f"{pressure_base.__class__.__name__}": pressure_base.Units.serialize(),
+    f"{mass_base.__class__.__name__}": mass_base.Units.serialize(),
+    f"{force_base.__class__.__name__}": force_base.Units.serialize(),
+    f"{power_base.__class__.__name__}": power_base.Units.serialize(),
+    f"{volumetric_flow_base.__class__.__name__}": volumetric_flow_base.Units.serialize(),
+    f"{mass_flow_base.__class__.__name__}": mass_flow_base.Units.serialize(),
+    f"{density_base.__class__.__name__}": density_base.Units.serialize(),
+    f"{percentage_base.__class__.__name__}": percentage_base.Units.serialize(),
+    f"{adimentional_base.__class__.__name__}": adimentional_base.Units.serialize(),
+    f"{volume_base.__class__.__name__}": volume_base.Units.serialize()
+}
+
+DATATYPES = [
+    {'label': 'Float', 'value': 'float'},
+    {'label': 'Integer', 'value': 'integer'},
+    {'label': 'Boolean', 'value': 'boolean'},
+    {'label': 'String', 'value': 'string'}
+]

automation/variables/adimentional.py

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

automation/variables/current.py

@@ -0,0 +1,71 @@
+from ..utils.units import EngUnit, UnitError, UnitSerializer
+
+class Current(EngUnit):
+    r"""
+    Creates a current object pruebaaaaa that can store a current value and 
+    convert between units of current.
+
+    :param value: The current value (engineering value)
+    :type value: int | float
+    :param unit: The unit of the current (e.g., "A", "mA", "kA")
+    :type unit: str
+    :return: A new Current object
+    :rtype: Current
+
+    Example usage:
+
+    .. code-block:: python
+
+        >>> from automation.variables.current import Current
+        >>> current = Current(value=1.0, unit="A")
+        >>> current.value
+        1.0
+        >>> current.unit
+        'A'
+        >>> current.convert(to_unit="kA")
+        0.001
+        >>> Current.convert_value(value=1.0, from_unit="A", to_unit="mA")
+        1000.0
+        >>> Current.convert_values(values=[1.0, 10.0], from_unit="A", to_unit="mA")
+        [1000.0, 10000.0]
+        >>> current.change_unit(unit="kA")
+        0.001
+        >>> current.unit
+        'kA'
+        >>> current.get_value()
+        [0.001, 'kA']
+        >>> print(current)
+        0.001 kA
+        >>> current2 = Current(value=3.0, unit="mA")
+        >>> current_result = current + current2
+        >>> print(current_result)
+        0.001003 kA
+        >>> current_result = current * current2
+        >>> print(current_result)
+        3e-09 kA
+        >>> current_result = current / current2
+        >>> print(current_result)
+        333.3333333333333 kA
+        >>> current_result = current ** current2
+        >>> print(current_result)
+        0.9999792769488884 kA
+    """
+    
+    class Units(UnitSerializer):
+        A = 'A'
+        mA = 'mA'
+        kA = 'kA'
+    
+    conversions = {
+        'A' : 1,
+        'mA' : 1000,
+        'kA' : 0.001
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Current.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Current.Units.list()}")
+        
+        super(Current, self).__init__(value=value, unit=unit)

automation/variables/density.py

@@ -0,0 +1,115 @@
+from ..utils.units import *
+
+class Density(EngUnit):
+    """Creates a density object that can store a density value and 
+    convert between units of density.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Density Object]\n
+
+    ```python
+    >>> from automation.variables.density import Density
+    >>> density = Density(value=1.0, unit="kg/m3")
+    >>> density.value
+    1.0
+    >>> density.unit
+    'kg/m3'
+    >>> density.convert(to_unit="lb/ml")
+    2.2046226218000004e-06
+    >>> Density.convert_value(value=1.0, from_unit="kg/m3", to_unit="g/ml")
+    0.0010000000000000002
+    >>> Density.convert_values(values=[1.0, 10.0], from_unit="kg/m3", to_unit="g/ml")
+    [0.0010000000000000002, 0.010000000000000002]
+    >>> density.change_unit(unit="lb/ml")
+    2.2046226218000004e-06
+    >>> density.unit
+    'lb/ml'
+    >>> density.get_value()
+    [2.2046226218000004e-06, 'lb/ml']
+    >>> print(density)
+    2.2046226218000004e-06 lb/ml
+    >>> density2 = Density(value=3.0, unit="g/ml")
+    >>> density_result = density + density2
+    >>> print(density_result)
+    0.0066160724880218 lb/ml
+    >>> density_result = density * density2
+    >>> print(density_result)
+    1.458108271365692e-08 lb/ml
+    >>> density_result = density / density2
+    >>> print(density_result)
+    0.00033333333333333343 lb/ml
+    >>> density_result = density ** density2
+    >>> print(density_result)
+    0.9174608905185654 lb/ml
+
+    ```
+
+    """
+    
+    class Units(UnitSerializer):
+        kg_bbl = 'kg/bbl'
+        kg_gal = 'kg/gal'
+        kg_m3 = 'kg/m3'
+        kg_lt = 'kg/lt'
+        kg_ml = 'kg/ml'
+        g_bbl = 'g/bbl'
+        g_gal = 'g/gal'
+        g_m3 = 'g/m3'
+        g_lt = 'g/lt'
+        g_ml = 'g/ml'
+        mg_bbl = 'mg/bbl'
+        mg_gal = 'mg/gal'
+        mg_m3 = 'kmg/m3'
+        mg_lt = 'mg/lt'
+        mg_ml = 'mg/ml'
+        lb_bbl = 'lb/bbl'
+        lb_gal = 'lb/gal'
+        lb_m3 = 'lb/m3'
+        lb_lt = 'lb/lt'
+        lb_ml = 'lb/ml'
+        metricTon_bbl = 'metricTon/bbl'
+        metricTon_gal = 'metricTon/gal'
+        metricTon_m3 = 'metricTon/m3'
+        metricTon_lt = 'metricTon/lt'
+        metricTon_ml = 'metricTon/ml'
+    
+    conversions = {
+        'kg/bbl' : 1.0,
+        'g/bbl' : 1.0 * 1000,
+        'mg/bbl' : 1.0 * 1000 * 1000,
+        'metricTon/bbl' : 1.0 / 1000.0,
+        'lb/bbl' : 2.2046226218,
+
+        'kg/gal' : 1.0 / 42.0,
+        'g/gal' : 1.0 * 1000 / 42.0,
+        'mg/gal' : 1.0 * 1000 * 1000 / 42.0,
+        'metricTon/gal' : 1.0 / 1000.0 / 42.0,
+        'lb/gal' : 2.2046226218 / 42.0,
+
+        'kg/m3' : 1.0 / 0.158987294928,
+        'g/m3' : 1.0 * 1000 / 0.158987294928,
+        'mg/m3' : 1.0 * 1000 * 1000 / 0.158987294928,
+        'metricTon/m3' : 1.0 / 1000.0 / 0.158987294928,
+        'lb/m3' : 2.2046226218 / 0.158987294928,
+
+        'kg/lt' : 1.0 / 158.987294928,
+        'g/lt' : 1.0 * 1000 / 158.987294928,
+        'mg/lt' : 1.0 * 1000 * 1000 / 158.987294928,
+        'metricTon/lt' : 1.0 / 1000.0 / 158.987294928,
+        'lb/lt' : 2.2046226218 / 158.987294928,
+
+        'kg/ml' : 1.0 / 158987.294928,
+        'g/ml' : 1.0 * 1000 / 158987.294928,
+        'mg/ml' : 1.0 * 1000 * 1000 / 158987.294928,
+        'metricTon/ml' : 1.0 / 1000.0 / 158987.294928,
+        'lb/ml' : 2.2046226218 / 158987.294928,
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Density.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Density.Units.list()}")
+        
+        super(Density, self).__init__(value=value, unit=unit)

automation/variables/eng_time.py

@@ -0,0 +1,68 @@
+from ..utils.units import *
+
+class Time(EngUnit):
+    """Creates a eng_time object that can store a eng_time value and 
+    convert between units of eng_time.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Time Object]\n
+
+    ```python
+    >>> from automation.variables.eng_time import Time
+    >>> eng_time = Time(value=1.0, unit="hr")
+    >>> eng_time.value
+    1.0
+    >>> eng_time.unit
+    'hr'
+    >>> eng_time.convert(to_unit="minute")
+    60.0
+    >>> Time.convert_value(value=1.0, from_unit="hr", to_unit="s")
+    3600.0
+    >>> Time.convert_values(values=[1.0, 10.0], from_unit="hr", to_unit="s")
+    [3600.0, 36000.0]
+    >>> eng_time.change_unit(unit="minute")
+    60.0
+    >>> eng_time.unit
+    'minute'
+    >>> eng_time.get_value()
+    [60.0, 'minute']
+    >>> print(eng_time)
+    60.0 minute
+    >>> eng_time2 = Time(value=3.0, unit="s")
+    >>> eng_time_result = eng_time + eng_time2
+    >>> print(eng_time_result)
+    60.05 minute
+    >>> eng_time_result = eng_time * eng_time2
+    >>> print(eng_time_result)
+    3.0 minute
+    >>> eng_time_result = eng_time / eng_time2
+    >>> print(eng_time_result)
+    1200.0 minute
+
+    ```
+
+    """
+    
+    class Units(UnitSerializer):
+        ms = 'ms'
+        s = 's'
+        minute = 'minute'
+        hr = 'hr'
+        day = 'day'
+    
+    conversions = {
+        'ms' : 1000.0,
+        's' : 1.0,
+        'minute' : 1.0 / 60.0,
+        'hr' : 1.0 / 60.0 / 60.0,
+        'day' : 1.0 / 60.0 / 60.0 / 24.0
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Time.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Time.Units.list()}")
+        
+        super(Time, self).__init__(value=value, unit=unit)

automation/variables/force.py

@@ -0,0 +1,90 @@
+from ..utils.units import *
+
+class Force(EngUnit):
+    """Creates a force object that can store a force value and 
+    convert between units of force.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Force Object]\n
+
+    ```python
+    >>> from automation.variables.force import Force
+    >>> force = Force(value=1.0, unit="N")
+    >>> force.value
+    1.0
+    >>> force.unit
+    'N'
+    >>> force.convert(to_unit="kgf")
+    0.1019716213
+    >>> Force.convert_value(value=1.0, from_unit="N", to_unit="lbf")
+    0.2248089431
+    >>> Force.convert_values(values=[1.0, 10.0], from_unit="N", to_unit="lbf")
+    [0.2248089431, 2.248089431]
+    >>> force.change_unit(unit="kgf")
+    0.1019716213
+    >>> force.unit
+    'kgf'
+    >>> force.get_value()
+    [0.1019716213, 'kgf']
+    >>> print(force)
+    0.1019716213 kgf
+    >>> force2 = Force(value=3.0, unit="lbf")
+    >>> force_result = force + force2
+    >>> print(force_result)
+    1.4627487313277014 kgf
+    >>> force_result = force * force2
+    >>> print(force_result)
+    0.1387606481374532 kgf
+    >>> force_result = force / force2
+    >>> print(force_result)
+    0.07493631436666666 kgf
+    >>> force_result = force ** force2
+    >>> print(force_result)
+    0.04474673588461198 kgf
+
+    ```
+    """
+
+    class Units(UnitSerializer):
+        N = 'N'
+        kN = 'kN'
+        MN = 'MN'
+        GN = 'GN'
+        gf = 'gf'
+        kgf = 'kgf'
+        dyn = 'dyn'
+        Jm = 'J/m'
+        Jcm = 'J/cm'
+        shortTonF = 'shortTonF'
+        longTonF = 'longTonF'
+        kipf = 'kipf'
+        lbf = 'lbf'
+        ozf = 'ozf'
+        pdl = 'pdl'
+
+    conversions = {
+        'N' : 1.0,
+        'kN' : 1.0 / 1000.0,
+        'MN' : 1.0 / 1000000.0,
+        'GN' : 1.0 / 1000000000.0,
+        'gf' : 1.019716213e+2,
+        'kgf' : 1.019716213e-1,
+        'dyn' : 1e+5,
+        'J/m' : 1.0,
+        'J/cm' : 100.0,
+        'shortTonF' : 1.124045e-4,
+        'longTonF' : 1.003611e-4,
+        'kipf' : 2.248089e-4,
+        'lbf' : 2.248089431e-1,
+        'ozf' : 3.5969430896,
+        'pdf' : 7.2330138512
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Force.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Force.Units.list()}")
+        
+        super(Force, self).__init__(value=value, unit=unit)

automation/variables/length.py

@@ -0,0 +1,104 @@
+from ..utils.units import EngUnit, UnitSerializer, UnitError
+
+class Length(EngUnit):
+    """Creates a length object that can store a length value and 
+    convert between units of length.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Length Object]\n
+
+    ```python
+    >>> from automation.variables.length import Length
+    >>> length = Length(value=1.0, unit="m")
+    >>> length.value
+    1.0
+    >>> length.unit
+    'm'
+    >>> length.convert(to_unit="inch")
+    39.3701
+    >>> Length.convert_value(value=1.0, from_unit="m", to_unit="cm")
+    100.0
+    >>> Length.convert_values(values=[1.0, 10.0], from_unit="m", to_unit="cm")
+    [100.0, 1000.0]
+    >>> length.change_unit(unit="inch")
+    39.3701
+    >>> length.unit
+    'inch'
+    >>> length.get_value()
+    [39.3701, 'inch']
+    >>> print(length)
+    39.3701 inch
+    >>> length2 = Length(value=3.0, unit="cm")
+    >>> length_result = length + length2
+    >>> print(length_result)
+    40.551203 inch
+    >>> length_result = length * length2
+    >>> print(length_result)
+    46.500143220300004 inch
+    >>> length_result = length / length2
+    >>> print(length_result)
+    33.333333333333336 inch
+    >>> length_result = length ** length2
+    >>> print(length_result)
+    76.56952620577046 inch
+    
+    ```
+    """
+    
+    class Units(UnitSerializer):
+        fm = 'fm' 
+        pm = 'pm' 
+        nm = 'nm' 
+        um = 'um' 
+        mm = 'mm' 
+        cm = 'cm'
+        m = 'm'
+        dam = 'dam'
+        hm = 'hm' 
+        km = 'km'
+        Mm = 'Mm' 
+        Gm = 'Gm'
+        Tm = 'Tm'
+        Pm = 'Pm'
+
+        inch = 'inch'
+        ft = 'ft'
+        yd = 'yd'
+        mi = 'mi'
+
+        nautMi = 'nautMi'
+        lightYear = 'lightYear'
+
+    conversions = {
+        'fm' : 1000000000000000,
+        'pm' : 1000000000000,
+        'nm' : 1000000000,
+        'um' : 1000000,
+        'mm' : 1000,
+        'cm' : 100,
+        'm' : 1.0,
+        'dam' : 0.1,
+        'hm' : 0.01,
+        'km' : 0.001,
+        'Mm' : 0.000001,
+        'Gm' : 0.000000001,
+        'Tm' : 0.000000000001,
+        'Pm' : 0.000000000000001,
+
+        'inch' : 39.3701,
+        'ft' : 3.28084,
+        'yd' : 1.09361,
+        'mi' : 0.000621371,
+
+        'nautMi' : 1.0 / 1852.0,
+        'lightYear' : 1.0 / (9.4607304725808 * (10**15))
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Length.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Length.Units.list()}")
+        
+        super(Length, self).__init__(value=value, unit=unit)

automation/variables/mass.py

@@ -0,0 +1,80 @@
+from ..utils.units import *
+
+class Mass(EngUnit):
+    """Creates a mass object that can store a mass value and 
+    convert between units of mass.
+
+    :param value: [int|float] Engineering value\n
+    :param unit: [str] Engineering unit\n
+    :return: [Mass Object]\n
+
+    ```python
+    >>> from automation.variables.mass import Mass
+    >>> mass = Mass(value=1.0, unit="kg")
+    >>> mass.value
+    1.0
+    >>> mass.unit
+    'kg'
+    >>> mass.convert(to_unit="lb")
+    2.2046226218
+    >>> Mass.convert_value(value=1.0, from_unit="kg", to_unit="g")
+    1000.0
+    >>> Mass.convert_values(values=[1.0, 10.0], from_unit="kg", to_unit="g")
+    [1000.0, 10000.0]
+    >>> mass.change_unit(unit="lb")
+    2.2046226218
+    >>> mass.unit
+    'lb'
+    >>> mass.get_value()
+    [2.2046226218, 'lb']
+    >>> print(mass)
+    2.2046226218 lb
+    >>> mass2 = Mass(value=3.0, unit="g")
+    >>> mass_result = mass + mass2
+    >>> print(mass_result)
+    2.2112364896654 lb
+    >>> mass_result = mass * mass2
+    >>> print(mass_result)
+    0.014581082713656917 lb
+    >>> mass_result = mass / mass2
+    >>> print(mass_result)
+    333.33333333333337 lb
+    >>> mass_result = mass ** mass2
+    >>> print(mass_result)
+    1.0052423283919558 lb
+
+    ```
+    """
+    
+    class Units(UnitSerializer):
+        kg = 'kg'
+        g = 'g'
+        mg = 'mg'
+        lb = 'lb'
+        metricTon = 'metricTon'
+        oz = 'oz'
+        grain = 'grain'
+        shortTon = 'shortTon'
+        longTon = 'longTon'
+        slug = 'slug'
+    
+    conversions = {
+        'kg' : 1.0,
+        'g' : 1000.0,
+        'mg' : 1000000.0,
+        'metricTon' : 1.0 / 1000.0,
+        'lb' : 2.2046226218,
+        'oz' : 35.274,
+        'grain' : 2.2046226218 * 7000.0,
+        'shortTon' : 1.0 / 907.185,
+        'longTon' : 1.0 / 1016.047,
+        'slug' : 1.0 / 14.5939029
+    }
+
+    def __init__(self, value, unit):
+
+        if unit not in Mass.Units.list():
+
+            raise UnitError(f"{unit} value is not allowed for {self.__class__.__name__} object - you can use: {Mass.Units.list()}")
+        
+        super(Mass, self).__init__(value=value, unit=unit)