# -*- coding: utf-8 -*- # Copyright © 2016, German Neuroinformatics Node (G-Node) # # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted under the terms of the BSD License. See # LICENSE file in the root of the Project. import re try: from collections.abc import Sequence except ImportError: from collections import Sequence from ..exceptions import InvalidUnit # Base32hex alphabet (RFC 4648) ID_ALPHABET = "0123456789abcdefghijklmnopqrstuv" # Unit scaling, SI only, substitutions for micro and ohm... PREFIXES = "(Y|Z|E|P|T|G|M|k|h|da|d|c|m|u|n|p|f|a|z|y)" UNITS = ("(m|g|s|A|K|mol|cd|Hz|N|Pa|J|W|C|V|F|S|Wb|T|H|lm|lx|Bq|Gy|Sv|kat|l|L|" "Ohm|%|dB|rad)") POWER = "(\\^[+-]?[1-9]\\d*)" PREFIX_FACTORS = {"y": 1.0e-24, "z": 1.0e-21, "a": 1.0e-18, "f": 1.0e-15, "p": 1.0e-12, "n": 1.0e-9, "u": 1.0e-6, "m": 1.0e-3, "c": 1.0e-2, "d": 1.0e-1, "da": 1.0e1, "h": 1.0e2, "k": 1.0e3, "M": 1.0e6, "G": 1.0e9, "T": 1.0e12, "P": 1.0e15, "E": 1.0e18, "Z": 1.0e21, "Y": 1.0e24} def sanitizer(unit): """ Sanitizes a unit string. That is, it is de-blanked, and mu and µ symbols are changed to u for micro. :param unit: The unit that needs to be sanitized. :returns: the sanitized unit. :rtype: str """ # micro = "\u03bc" micro = "µ" # mugr = "\u00b5" mugr = "μ" return unit.replace(" ", "").replace("mu", "u").\ replace(micro, "u").replace(mugr, "u") def is_si(unit): """ Determines whether a unit is a recognized SI unit. :param unit: The unit that needs to be checked. :returns: True if the unit is an SI unit, false otherwise. :rtype: bool """ return unit and (is_atomic(unit) or is_compound(unit)) def is_atomic(unit): """ Checked whether a unit string represents an atomic si unit, i.e. not a combination. :param unit: The unit to be checked. :returns: True if unit is atomic, False otherwise. :rtype: bool """ atomic_unit = re.compile( "^{prefix}?{unit}{power}?$".format(prefix=PREFIXES, unit=UNITS, power=POWER) ) return atomic_unit.match(unit) def is_compound(unit): """ Checks whether a unit string represents a combination of SI units. :param unit: The unit string. :returns: True if the unit string represents a combination of SI units, False otherwise. :rtype: bool """ atomic_unit = "{prefix}?{unit}{power}?".format( prefix=PREFIXES, unit=UNITS, power=POWER ) compound_unit = re.compile( "({atomic}(\\*|/))+{atomic}".format(atomic=atomic_unit) ) return unit and compound_unit.search(unit) def scalable(units_a, units_b): """ Checks whether units are scalable versions of the same SI unit. Method works on two lists and compares the corresponding units in both lists. :param unit_a: List of unit strings. :param unit_b: List of unit strings. :returns: True if all corresponding units are scalable. :rtype: bool """ if (isinstance(units_a, Sequence) and isinstance(units_b, Sequence) and not isinstance(units_a, str) and not isinstance(units_b, str)): if len(units_a) != len(units_b): return False for unit_a, unit_b in zip(units_a, units_b): if not scalable(unit_a, unit_b): return False return True if not (is_si(units_a) and is_si(units_b)): return False _, a_unit, a_power = split(units_a) _, b_unit, b_power = split(units_b) if a_unit != b_unit or a_power != b_power: return False return True def scaling(origin, destination): """ Returns the scaling factor to convert from one unit to another. :param origin: The original unit string. :param destination: The destination unit string. :returns: The scaling factor. :rtype: double """ scale = 1.0 if not scalable(origin, destination): raise InvalidUnit( "Origin unit and destination unit are not scalable version of the " "same SI unit!", "nixio.util.scaling" ) org_prefix, _, org_power = split(origin) dest_prefix, _, dest_power = split(destination) if org_prefix == dest_prefix and org_power == dest_power: return scale if not dest_prefix and org_prefix: scale = PREFIX_FACTORS[org_prefix] elif not org_prefix and dest_prefix: scale = 1.0 / PREFIX_FACTORS[dest_prefix] elif not org_prefix and not dest_prefix: scale = PREFIX_FACTORS[org_prefix] / PREFIX_FACTORS[dest_prefix] if org_power: power = int(org_power) scale **= power return scale def split(combined_unit): """ Splits a unit string into magnitude prefix, the base unit, and the power. :param combined_unit: The unit string. :returns: A tuple of prefix, base unit, and power. :rtype: tuple """ prefix_re = "(?P{})".format(PREFIXES) unit_re = "(?P{})".format(UNITS) power_re = "(?P{})".format(POWER) pup = re.compile(prefix_re + unit_re + power_re) prefix_matcher = re.compile(prefix_re + unit_re) unit_matcher = re.compile(unit_re + power_re) # u = re.compile(unit_re) # p = re.compile(prefix_re) match = pup.match(combined_unit) if match: prefix = match.group("prefix") unit = match.group("unit") power = match.group("power")[1:] return prefix, unit, power match = unit_matcher.match(combined_unit) if match: prefix = "" unit = match.group("unit") power = match.group("power")[1:] return prefix, unit, power match = prefix_matcher.match(combined_unit) if match: prefix = match.group("prefix") unit = match.group("unit") power = "" return prefix, unit, power prefix = "" unit = combined_unit power = "" return prefix, unit, power def invert_power(unit): prefix, unit, power = split(unit) if not power: return prefix + unit + "^-1" if power[0] == "-": power = power[1:] else: power = "^-" + power return prefix + unit + "^" + power def split_compound(compound_unit): """ Splits a compound unit (like mV/Hz) into the atomic units. :param compound_unit: The unit string. :returns: A tuple containing the atomic units. :rtype: tuple """ opt_pup = re.compile(PREFIXES + "?" + UNITS + POWER + "?") match = opt_pup.match(compound_unit) sep = "" atomic_units = [] while match and (match.end() < len(match.string)): suffix = match.string[match.end():] suffix = suffix.replace(" ", "") unit = match.group(0) if sep == "/": atomic_units.append(invert_power(unit)) else: atomic_units.append(unit) sep = suffix[0] match = opt_pup.match(suffix[1:]) unit = match.group(0) if sep == "/": atomic_units.append(invert_power(unit)) else: atomic_units.append(unit) return tuple(atomic_units)