def main(wf):
"""Run workflow Script Filter.
Args:
wf (workflow.Workflow): Current Workflow object.
"""
global ureg
ureg = UnitRegistry(wf.decode(DEFAULT_UNIT_DEFINITIONS))
ureg.default_format = 'P'
wf.magic_arguments['appkey'] = open_currency_instructions
if not len(wf.args):
return
query = wf.args[0] # .lower()
log.debug('query : %s', query)
handle_update(wf)
# Create data files if necessary
bootstrap(wf)
# Add workflow and user units to unit registry
register_units()
# Notify of available update
if wf.update_available:
wf.add_item('A newer version is available',
'Action this item to download & install the new version',
autocomplete='workflow:update',
icon=ICON_UPDATE)
# Load cached data
exchange_rates = wf.cached_data(CURRENCY_CACHE_NAME, max_age=0)
if exchange_rates: # Add exchange rates to conversion database
register_exchange_rates(exchange_rates)
if not wf.cached_data_fresh(CURRENCY_CACHE_NAME, CURRENCY_CACHE_AGE):
# Update currency rates
cmd = ['/usr/bin/python', wf.workflowfile('currency.py')]
run_in_background('update', cmd)
wf.rerun = 0.5
if is_running('update'):
wf.rerun = 0.5
if exchange_rates is None: # No data cached yet
wf.add_item(u'Fetching exchange rates…',
'Currency conversions will be momentarily possible',
icon=ICON_INFO)
else:
wf.add_item(u'Updating exchange rates…',
icon=ICON_INFO)
return convert(query)
def main(wf):
"""Run workflow Script Filter.
Args:
wf (workflow.Workflow): Current Workflow object.
"""
global ureg
ureg = UnitRegistry(wf.decode(DEFAULT_UNIT_DEFINITIONS))
ureg.default_format = 'P'
wf.magic_arguments['appkey'] = open_currency_instructions
if not len(wf.args):
return
query = wf.args[0] # .lower()
log.debug('query : %s', query)
handle_update(wf)
# Create data files if necessary
bootstrap(wf)
# Add workflow and user units to unit registry
register_units()
# Notify of available update
if wf.update_available:
wf.add_item('A newer version is available',
'Action this item to download & install the new version',
autocomplete='workflow:update',
icon=ICON_UPDATE)
# Load cached data
exchange_rates = wf.cached_data(CURRENCY_CACHE_NAME, max_age=0)
if exchange_rates: # Add exchange rates to conversion database
register_exchange_rates(exchange_rates)
if not wf.cached_data_fresh(CURRENCY_CACHE_NAME, CURRENCY_CACHE_AGE):
# Update currency rates
cmd = ['/usr/bin/python', wf.workflowfile('currency.py')]
run_in_background('update', cmd)
wf.rerun = 0.5
if is_running('update'):
wf.rerun = 0.5
if exchange_rates is None: # No data cached yet
wf.add_item(u'Fetching exchange rates…',
'Currency conversions will be momentarily possible',
icon=ICON_INFO)
else:
wf.add_item(u'Updating exchange rates…',
icon=ICON_INFO)
return convert(query)
def init_unit_reg():
ureg = UnitRegistry(on_redefinition="ignore")
ureg.define("hash = [hash] = H")
ureg.define("solution = [solution] = Sol")
ureg.define("bitcoin = [currency] = BTC")
ureg.default_format = '~'
Benchmarker.ureg = ureg
def convertTemp(T,top1,top2):
#The 3 lines here for ureg are just setting the baseline for our temperature units
ureg = UnitRegistry(autoconvert_offset_to_baseunit = True)
ureg.default_format = '.3f'
Q_ = ureg.Quantity
if top1 == 0:
home = Q_(T, ureg.degC)
elif top1 == 1:
home = Q_(T, ureg.degF)
elif top1 == 2:
home = Q_(T, ureg.degK)
return home.to(tTypes[top2])
def test_default_formatting(self):
ureg = UnitRegistry()
x = ureg.Quantity(4.12345678, UnitsContainer(meter=2, kilogram=1, second=-1))
for spec, result in (('L', r'4.12345678 \frac{kilogram \cdot meter^{2}}{second}'),
('P', '4.12345678 kilogram·meter²/second'),
('H', '4.12345678 kilogram meter<sup>2</sup>/second'),
('~', '4.12345678 kg * m ** 2 / s'),
('L~', r'4.12345678 \frac{kg \cdot m^{2}}{s}'),
('P~', '4.12345678 kg·m²/s'),
('H~', '4.12345678 kg m<sup>2</sup>/s'),
):
ureg.default_format = spec
self.assertEqual('{0}'.format(x), result)
def test_default_formatting(self):
ureg = UnitRegistry()
x = ureg.Quantity(4.12345678, UnitsContainer(meter=2, kilogram=1, second=-1))
for spec, result in (('L', r'4.12345678 \frac{kilogram \cdot meter^{2}}{second}'),
('P', '4.12345678 kilogram·meter²/second'),
('H', '4.12345678 kilogram meter<sup>2</sup>/second'),
('C', '4.12345678 kilogram*meter**2/second'),
('~', '4.12345678 kg * m ** 2 / s'),
('L~', r'4.12345678 \frac{kg \cdot m^{2}}{s}'),
('P~', '4.12345678 kg·m²/s'),
('H~', '4.12345678 kg m<sup>2</sup>/s'),
('C~', '4.12345678 kg*m**2/s'),
):
ureg.default_format = spec
self.assertEqual('{0}'.format(x), result)
def unit_conversion(result):
data = _get_entities(result)
response = {
"tts": "",
"file": "",
"save": True,
}
if data:
units = UnitRegistry()
units.default_format = '.2f'
base = data["base"]
conversion = data["conversion"]
try:
amount = data["amount"] * units(input_string=base)
except UndefinedUnitError as e:
response[
"tts"] = "The base unit does not appear to be in the unit registry."
response["file"] = "base_unit_undefined.mp3"
else:
try:
result = amount.to(conversion)
except DimensionalityError as e:
response[
"tts"] = f"I can't conver the base unit to the conversion unit."
response["file"] = "conversion_dimensionality.mp3"
except UndefinedUnitError as e:
response[
"tts"] = "The conversion unit does not appear to be in the unit registry."
response["file"] = "conversion_unit_undefined.mp3"
else:
response["tts"] = f"{amount} is {result}"
response["save"] = False
return response
response["tts"] = "I wasn't able to convert those units."
response["file"] = "conversion_failure.mp3"
return response
from pint import UnitRegistry
u = UnitRegistry()
u.default_format = '~P'
Q_ = u.Quantity
from .atoms import Atom, AtomMixed
from .unitCell import UnitCell
from .structure import Structure
from .simulation import Simulation
from .xray import Xray
from .xrayKin import XrayKin
from .xrayDyn import XrayDyn
__all__ = [
'Atom', 'AtomMixed', 'UnitCell', 'Structure', 'Simulation', 'Xray',
'XrayKin', 'XrayDyn', 'u', 'Q_'
]
# http://taurus-scada.org ## # Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain ## # Taurus is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. ## # Taurus is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. ## # You should have received a copy of the GNU Lesser General Public License # along with Taurus. If not, see <http://www.gnu.org/licenses/>. ## ############################################################################# """ This module provides a pint unit registry instance (`UR`) to be used by all taurus objects. It also provides the `Quantity` factory from that registry (also aliased as `Q_`). """ from pint import UnitRegistry # Ininitialize the unit registry for taurus UR = UnitRegistry() UR.default_format = '~' # use abbreviated units Q_ = Quantity = UR.Quantity
# Units handling
# here we assign the identifier 'unit' to the UnitRegistry
unit = UnitRegistry()
# use this to enable legacy handling of offset units
# TODO fix this to handle offsets the way pint wants us to since 0.7
unit.autoconvert_offset_to_baseunit = True
# append custom unit definitions and contexts
directory = os.path.dirname(__file__)
unit.load_definitions(directory + "/pint_custom_units.txt")
# activate the "chemistry" context globally
unit.enable_contexts("chem")
# set the default string formatting for pint quantities
unit.default_format = "P~"
def testfunc(val):
list = []
try:
list.append(float(val) * unit(""))
return list
except ValueError:
print("Value Error")
return None
class Parameter:
"""
Class for storing and retrieving measured parameter values together with their
CUSTOM_DEFINITIONS_FILENAME,
DECIMAL_PLACES,
DECIMAL_SEPARATOR,
DEFAULT_SETTINGS,
HELP_URL,
ICON_UPDATE,
THOUSANDS_SEPARATOR,
UPDATE_SETTINGS,
)
from defaults import Defaults
log = None
# Pint objects
ureg = UnitRegistry()
ureg.default_format = 'P'
# Q = ureg.Quantity
class NoToUnits(Exception):
"""Raised if there are no to units (or defaults)."""
class Input(object):
"""Parsed user query."""
def __init__(self, number, dimensionality, from_unit, to_unit=None):
self.number = number
self.dimensionality = dimensionality
self.from_unit = from_unit
self.to_unit = to_unit
def test_issue_1300(self):
ureg = UnitRegistry()
ureg.default_format = "~P"
m = ureg.Measurement(1, 0.1, "meter")
assert m.default_format == "~P"
Author: Matthew C. Jones Email: [email protected] :copyright: 2020 Matthew C. Jones :license: MIT License, see LICENSE for more details. """ from inspect import currentframe from numpy import sqrt from ambiance import Atmosphere from pint import UnitRegistry unit = UnitRegistry(system='mks') unit.default_format = '~P' dimless = unit('dimensionless') def name_of_var(var): """Find name of variables using local items. :var: dimensioned variable :returns: user-coded name of variable """ try: local_vars = currentframe().f_back.f_back.f_locals.items() match = [name for name, val in local_vars if val is var] except AttributeError: local_vars = currentframe().f_back.f_locals.items()
import numpy as np
import six
from IPython.display import Latex
import matplotlib.pyplot as plt
import pytablewriter
from enum import Enum
from collections import UserList
from pint import UnitRegistry, set_application_registry
from pint import __version__ as pint_version
u = UnitRegistry(autoconvert_offset_to_baseunit=True)
if int(pint_version.split('.')[0]) * 10 + int(pint_version.split('.')[1]) > 8:
u.setup_matplotlib(True)
u.default_format = '.4f~L'
set_application_registry(u)
np.set_printoptions(precision=3)
__all__ = [
'density', 'specific_volume', 'u', 'np', 'latex', 'V_flux', 'delta_u',
'speed', 'Delta_speed', 'isentropisch_work', 'isentropische_dT',
'isentropische_dV', 'isentropische_dv', 'isentropische_dP', 'isobaar_heat',
'isobaar_work', 'isobaar_dv', 'isobaar_dT', 'technical_work',
'delta_e_kin', 'delta_h', 'ProcessType', 'TransitionState', 'Transition',
'Cycle', 'States', 'mass_flux'
]
class ProcessType(Enum):
POLYTROPIC = -1
from flasgger.base import Swagger
from mongoengine import ValidationError
from mongoengine.base.datastructures import BaseDict
from itsdangerous import URLSafeTimedSerializer
from pint import UnitRegistry
from pint.unit import UnitDefinition
from pint.converters import ScaleConverter
from string import punctuation
from boltons.iterutils import remap, default_enter
ureg = UnitRegistry(preprocessors=[
lambda s: s.replace("%%", " permille "),
lambda s: s.replace("%", " percent "),
])
ureg.default_format = "P~"
ureg.define(UnitDefinition("percent", "%", (), ScaleConverter(0.01)))
ureg.define(UnitDefinition("permille", "%%", (), ScaleConverter(0.001)))
ureg.define(UnitDefinition("ppm", "ppm", (), ScaleConverter(1e-6)))
ureg.define(UnitDefinition("ppb", "ppb", (), ScaleConverter(1e-9)))
ureg.define("atom = 1")
ureg.define("bohr_magneton = e * hbar / (2 * m_e) = µᵇ = µ_B = mu_B")
ureg.define("electron_mass = 9.1093837015e-31 kg = mₑ = m_e")
Q_ = ureg.Quantity
delimiter, max_depth = ".", 3
max_dgts = 6
invalidChars = set(punctuation.replace("*", ""))
invalidChars.add(" ")
quantity_keys = {"display", "value", "unit"}
U_.define("__wrapped__ = 1"
) # <- hack to avoid an error with pytest (doctest activated)
U_.define("@alias point = count")
U_.define("transmittance = 1. / 100.")
U_.define("absolute_transmittance = 1.")
U_.define("absorbance = 1. = a.u.")
U_.define("Kubelka_Munk = 1. = K.M.")
U_.define("ppm = 1. = ppm")
U_.define(UnitDefinition("percent", "pct", (), ScaleConverter(1 / 100.0)))
U_.define(
UnitDefinition("weight_percent", "wt_pct", (),
ScaleConverter(1 / 100.0)))
U_.default_format = "~P"
Q_ = U_.Quantity
Q_.default_format = "~P"
set_application_registry(U_)
del UnitRegistry # to avoid importing it
else:
warn("Unit registry was already set up. Bypassed the new loading")
U_.enable_contexts("spectroscopy", "boltzmann", "chemistry")
# Context for NMR
# ------------------------------------------------------------------
def set_nmr_context(larmor):
# filename = resource_filename(PKG, 'spectrochempy.txt')
U_ = UnitRegistry(on_redefinition='ignore') # filename)
U_.define('__wrapped__ = 1') # <- hack to avoid an error with pytest (doctest activated)
U_.define('@alias point = count')
U_.define('transmittance = 1. / 100.')
U_.define('absolute_transmittance = 1.')
U_.define('absorbance = 1. = a.u.')
U_.define('Kubelka_Munk = 1. = K.M.')
U_.define('ppm = 1. = ppm')
U_.define(UnitDefinition('percent', 'pct', (), ScaleConverter(1 / 100.0)))
U_.define(UnitDefinition('weight_percent', 'wt_pct', (), ScaleConverter(1 / 100.0)))
U_.default_format = '' # .2fK'
Q_ = U_.Quantity
Q_.default_format = '' # .2fK'
set_application_registry(U_)
del UnitRegistry # to avoid importing it
else:
warn('Unit registry was already set up. Bypassed the new loading')
U_.enable_contexts('spectroscopy', 'boltzmann', 'chemistry')
# Context for NMR
# ----------------------------------------------------------------------------------------------------------------------
def set_nmr_context(larmor):
import numbers
import numpy as np
import uncertainties
from interval import imath, inf, interval
from IPython.display import Latex, display
from pint import DimensionalityError, UnitRegistry
from typeguard import typechecked
from uncertainties import ufloat
ureg = UnitRegistry()
ureg.default_format = "~P"
ureg.define("GRAPI = 1.0") # added base unit for gamma ray log
Q_ = ureg.Quantity
esc = lambda s: s.replace('"\"', '"\\"')
@typechecked
class Limits:
def __init__(self, limits: (tuple, list)):
assert len(limits) == 2
lower, upper = limits
try:
assert lower.dimensionality == upper.dimensionality
except DimensionalityError as exc:
raise exc
try:
assert isinstance(lower.m, numbers.Number)
assert isinstance(upper.m, numbers.Number)
except AssertionError as e:
from pint import UnitRegistry
# here we assign the identifier 'unit' to the UnitRegistry
unit = UnitRegistry()
#use this to enable legacy handling of offset units
# TODO fix this to handle offsets the way pint wants us to since 0.7
unit.autoconvert_offset_to_baseunit = True
# append custom unit definitions and contexts
import os
directory = os.path.dirname(__file__)
unit.load_definitions(directory + '/pint_custom_units.txt')
# activate the "chemistry" context globally
unit.enable_contexts('chem')
# set the default string formatting for pint quantities
unit.default_format = 'P~'
def testfunc(val):
list = []
try:
list.append(float(val) * unit(''))
return list
except ValueError:
print('Value Error')
return None
class Parameter:
'''
Class for storing and retrieving measured parameter values together with their
from pint import UnitRegistry
units = UnitRegistry()
units.default_format = ".5~P"
units.default_LaTeX_format = ":~L"
Quantity = units.Quantity
# define custom units for dealing with humid air
# lbmol
units.define("pound_mole = 453.59237*mol = lbmol")
# mass of dry air
units.define("gram_dry_air = [mass_dry_air] = g_a = g_dry_air = ga ")
units.define(
"pound_dry_air = 453.59237 * gram_dry_air = lb_dry_air = lba = lb_a = lbm_a = lbma = lb_dry_air = lbm_dry_air"
)
# mass of humid air
units.define("gram_humid_air = [mass_humid_air] = gha = g_ha = g_humid_air")
units.define(
"pound_humid_air = 453.59237 * gram_humid_air = lb_humid_air = lbha = lbmha = lbm_humid_air"
)
# mass of water
units.define("gram_water = [mass_water] = g_water = gw = g_w")
units.define(
"pound_water = 453.59237 * gram_water = lb_water = lb_w = lbw = lbmw = lbm_w = lbm_water"
)
# molecules of dry air
units.define(
"mole_dry_air = [substance_dry_air] = mol_dry_air = mol_a = mola = mol_da = molda"
)
units.define(
"pound_mole_dry_air = 453.59237 * mol_dry_air = lbmol_dry_air = lbmol_a = lbmola = lbmol_da = lbmolda"
from pint import UnitRegistry ureg = UnitRegistry() Q = ureg.Quantity ureg.default_format = '.2f~P'
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
from pint import UnitRegistry
ureg = UnitRegistry()
ureg.default_format = "Lx"
mpl.rcParams["text.latex.preamble"] = r"\usepackage{xfrac}\usepackage{siunitx}"
def plot_halftime_sequence():
halftime = pd.read_csv("data/scope_4_1.csv", header=[0, 1])
fig = plt.figure()
ax = fig.add_subplot(211)
ax.plot(halftime["x-axis"], halftime["1"], label="Burst Sequenz")
ax.legend()
ax.set_xlabel(r"$t \:\:/\:\: \si{\second}$")
ax.set_ylabel(r"$U \:\:/\:\: \si{\volt}$")
peak = halftime[25000:29500]
peak["1"] -= peak["1"].values[0]
mask = peak["1"] <= peak["1"].min() / 2
halftimes_x = peak["x-axis"].values[mask][[0, -1]]
'reaction'
])
#: Chemical engineering plant cost index (defaults to 567.5 at 2017)
CE = 567.5
# %% Import base utils
import pandas as pd
import numpy as np
from pint import UnitRegistry
import os
# Set pint Unit Registry
_ureg = UnitRegistry()
_ureg.default_format = '~P'
_ureg.load_definitions(
os.path.dirname(os.path.realpath(__file__)) + '/my_units_defs.txt')
_Q = _ureg.Quantity
_Q._repr_latex_ = _Q._repr_html_ = _Q.__str__ = _Q.__repr__ = lambda self: self.__format__(
'')
# Set number of digits displayed
np.set_printoptions(suppress=False)
np.set_printoptions(precision=3)
pd.options.display.float_format = '{:.3g}'.format
pd.set_option('display.max_rows', 35)
pd.set_option('display.max_columns', 10)
pd.set_option('max_colwidth', 35)
del np, pd, os, UnitRegistry
from pint import UnitRegistry
# here we assign the identifier 'unit' to the UnitRegistry
unit = UnitRegistry()
#use this to enable legacy handling of offset units
# TODO fix this to handle offsets the way pint wants us to since 0.7
unit.autoconvert_offset_to_baseunit = True
# append custom unit definitions and contexts
import os
directory = os.path.dirname(__file__)
unit.load_definitions(directory+'/pint_custom_units.txt')
# activate the "chemistry" context globally
unit.enable_contexts('chem')
# set the default string formatting for pint quantities
unit.default_format = 'P~'
def testfunc(val):
list = []
try:
list.append(float(val) * unit(''))
return list
except ValueError:
print('Value Error')
return None
class Parameter:
'''
Class for storing and retrieving measured parameter values together with their
units, context, and reference information.
import sqlite3 as sql
import pandas as pd
import random
import math
import os
from pint import UnitRegistry, UndefinedUnitError
dbConn = sql.connect(":memory:", check_same_thread=False)
dbConn.row_factory = sql.Row
u_reg = UnitRegistry()
u_reg.default_format = "H"
def setup():
cur = dbConn.cursor()
for root, dirs, files in os.walk("data"):
for file in files:
if file.endswith(".csv"):
readFile = pd.read_csv(os.path.join(root, file))
readFile.to_sql(file.split(".")[0], dbConn, index=False)
cur.execute("SELECT * FROM " + file.split(".")[0] + ";")
def get_random_record(record_type: str):
if record_type not in ["volumes", "times", "mass", "lengths"]:
return None
cur = dbConn.cursor()
cur.execute("SELECT * FROM " + record_type +
" WHERE rowid = abs(random()) % (SELECT max(rowid) FROM " +
record_type + ") + 1;")
# *****************************************************************
# IonControl: Copyright 2016 Sandia Corporation
# This Software is released under the GPL license detailed
# in the file "license.txt" in the top-level IonControl directory
# *****************************************************************
from pint import UnitRegistry, set_application_registry
from functools import lru_cache
from pint.util import UnitsContainer, infer_base_unit
ureg = UnitRegistry()
ureg.default_format = "~"
ureg.define('samples = count / second')
ureg.define('sample = count / second')
set_application_registry(ureg)
Q = ureg.Quantity
# define a hash function for quantity
def quantityHash(self):
return hash(self.to_tuple())
Q.__hash__ = quantityHash
def is_Q(q):
return isinstance(q, Q)
def value(q, unit=None):
if is_Q(q):
return q.m_as(unit)
