Actualizar de la 3.3 a la 4.0

La 4.0 rompe duro y no lleva capa de compatibilidad. Casi nada se ha borrado: de los 885 nombres que la raíz exportaba en la 3.3.0, diez no existen ya en ningún sitio y el resto simplemente vive en una dirección con nombre en vez de en una plana. Así que el trabajo es sobre todo un barrido de imports, y esta página es sobre todo un mapa.

Con las dos primeras secciones arreglas los imports. La tercera léela aunque tengas prisa, porque en tres sitios el arreglo evidente es el equivocado, y uno de esos tres cambia un número sin levantar nada.

En la 3.3.0 la raíz reexportaba la biblioteca entera, así que from phonometry import laeq funcionaba para casi cualquier nombre. Hoy la raíz exporta veinticinco cosas: los veintiún subpaquetes, las tres clases que no pertenecen a ningún dominio concreto (Signal, ReportMetadata, PhonometryWarning) y __version__.

import phonometry

print(len(phonometry.__all__))          # 25
print("laeq" in phonometry.__all__)     # False

from phonometry.signals import laeq     # esta es la grafía nueva

Medido sobre la superficie entera, 872 de aquellos 885 nombres de la raíz los publica hoy exactamente un subpaquete, ninguno dos, y ninguno necesita una ruta más profunda que phonometry.<subpaquete>. Otros tres siguen en la raíz, donde siempre estuvieron. Así que el cambio no tiene ambigüedad: busca el subpaquete e importa de él.

La forma de atributo no se retiró nunca, que es el cambio más pequeño posible para el código que tiraba de la raíz:

from phonometry import filters

_, _, _, labels = filters.nominal_frequencies(1)
print(labels)

En vez de buscar cada uno en la referencia, pregúntaselo al paquete instalado:

import importlib
import pkgutil

import phonometry


def whereis(name):
    """Cada módulo público que publica `name`, del menos profundo al que más."""
    found = ["phonometry"] if name in phonometry.__all__ else []
    for attribute in phonometry.__all__:
        package = getattr(phonometry, attribute)
        if not hasattr(package, "__path__"):
            continue
        modules = [package.__name__]
        modules += [m.name for m in pkgutil.walk_packages(package.__path__, package.__name__ + ".")]
        for module_name in modules:
            if any(part.startswith("_") for part in module_name.split(".")):
                continue
            try:
                module = importlib.import_module(module_name)
            except ImportError:
                continue
            if name in getattr(module, "__all__", ()):
                found.append(module_name)
    return sorted(found, key=lambda path: path.count("."))


print(whereis("laeq")[0])                  # phonometry.signals
print(whereis("reverberation_time")[0])    # phonometry.room
print(whereis("sensitivity")[0])           # phonometry.metrology
print(whereis("Signal")[0])                # phonometry

Recorre el árbol en unos dos segundos. Cuando devuelve varias rutas, la menos profunda es el import canónico: un subpaquete reexporta lo que publican sus propios módulos, y esa ruta corta es la que usan las guías y los tests. Los cuatro nombres que la raíz sigue publicando por su cuenta, Signal, PhonometryWarning, ReportMetadata y __version__, vuelven como phonometry a secas. Una lista vacía significa que el nombre está en la última sección de esta página.

Cinco de los treinta módulos que cambiaron de ruta no se mudaron a una dirección nueva. Se dividieron, y quien siga sólo la primera mitad de la partición se lleva un ImportError por el resto. Merece la pena revisarlos uno a uno, y el paquete privado de renderizado va con ellos porque le pasó lo mismo:

Los otros veinticinco se mudaron enteros, y el resolutor de arriba los encuentra sin leer esta tabla. Cada uno de los tres primeros era alcanzable por dos rutas en la 3.3.0, la plana y la de dentro de su paquete, y las dos han desaparecido.

Todo lo demás de esta página se anuncia en cuanto lo ejecutas, y el arreglo es el que parece. Estos tres no son así.

air_density_iso y speed_of_sound_iso documentaban y consumían su temperatura en kelvin. Sus sucesores toman grados Celsius, como el resto de la biblioteca. El nombre cambió, así que el import falla y te enteras, pero el problema es el argumento que arrastras: 293,15 es un número de aspecto legítimo en cualquiera de las dos unidades.

from phonometry.materials import speed_of_sound_iso10534

print(round(float(speed_of_sound_iso10534(temperature_c=20.0)), 5))      # 343.28784
print(round(float(speed_of_sound_iso10534(temperature_c=293.15)), 5))    # 477.13003

343,29 m/s frente a 477,13 m/s: un 39 % de error, sin excepción ninguna, y cada coeficiente de absorción calculado a partir de ahí sale mal en una cantidad de aspecto plausible. Convierte el valor, no te limites a renombrar la palabra clave.

Con la conversión aplicada, los dos devuelven exactamente lo que devolvían en la 3.3.0, bit a bit.

El auxiliar de ISO 17497-1 que se llamaba igual tomaba grados Celsius, así que ahí no hay conversión que hacer. La trampa es el sustituto. fluids.air() usa un modelo del medio más completo que aquella fórmula de una línea de la ISO 17497-1, y a 20 °C responde 343,99 m/s donde el auxiliar viejo respondía 343,20 m/s. Es poco, y no es nada despreciable si estás reproduciendo una medición hecha con el número antiguo. El apartado 8 de la ISO 17497-1 imprime la fórmula si necesitas ese apartado exacto.

transmission_loss pasó a propagation_loss, cosa que el import detecta, y con él se renombró el campo de dentro del resultado. Ese no levanta nada: un PropagationLossResult no tiene .tl, así que el AttributeError aparece allí donde lo leas, que puede quedar lejos de la llamada.

from phonometry.underwater.propagation.closed_form import propagation_loss

result = propagation_loss([1000.0], 1000.0)
print(round(float(result.pl[0]), 5))    # 60.06013, el número que guardaba .tl

El mismo renombrado llega a underwater.sonar_equation, cuyo parámetro transmission_loss es ahora propagation_loss.

Cinco puntos de entrada ya no toman las condiciones ambientales como números sueltos. Ahí no basta con renombrar la palabra clave, porque el parámetro ha desaparecido del todo:

Las sustituciones punto a punto del rotorcraft fueron por el mismo camino: bank_angle y path_angle son ahora RotorcraftTrackState(bank_angle_deg=..., path_angle_deg=...).

from phonometry.aircraft.airport_noise import AerodromeAtmosphere

atmosphere = AerodromeAtmosphere(temperature_c=15.0, atmospheric_pressure_kpa=101.325)
print(atmosphere.temperature_c, atmosphere.atmospheric_pressure_kpa)

En todo lo demás, las condiciones ambientales conservaron su sitio y ganaron un sufijo. La regla es que un parámetro público que nombra una magnitud dimensional termina en la unidad que teclea quien llama, porque el número es donde se pierde la unidad y ninguna guardia puede cazarlo por magnitud: 101,325 y 101325 son las dos presiones legítimas en esta biblioteca.

Un caso merece mención propia porque era una trampa y no una incomodidad. critical_angle era un campo en radianes en un resultado y un parámetro en grados en las dos funciones que estaban una pantalla más abajo, o sea la misma palabra para dos cosas separadas por un factor 57. Ahora es critical_angle_rad en el resultado y critical_angle_deg en los parámetros.

transmission_loss= pasó a propagation_loss= sólo en los resultados de sónar y de propagación numérica submarina. ReactiveSilencerResult y SoundReductionResult siguen llamando al suyo transmission_loss=, y con razón: es como lo llaman las normas que hay detrás.

Las funciones de la EN 29052-1 de materials siguen la misma regla, con la unidad de cada magnitud al final de su nombre:

La resistividad al flujo es la que se gana la palabra clave. La EN 29052-1 pone sus umbrales en kPa·s/m², y todas las demás resistividades al flujo de la biblioteca van en Pa·s/m², una unidad mil veces menor, así que una cifra en Pa·s/m² pasada por posición caía sin aviso en la rama equivocada del apartado 8.2; ahora se escribe por su nombre. Y por debajo de 100 kPa·s/m², installed_dynamic_stiffness ya no toma como cero un término de gas ausente: la 3.3.0 devolvía $s_{\mathrm{t}}^{\prime }$ con installed_dynamic_stiffness(20e6, 50.0), la Fórmula 6 sin su segundo término, y la 4.0 lanza un error y pide $s_{\mathrm{a}}^{\prime }$.

Dos reglas dejaron 37 firmas keyword-only. Una condición o una opción que lleva valor por defecto se escribe por su nombre, y toda bandera booleana pública es keyword-only. Las dos existen porque el sitio donde se pierde el significado es la llamada: air_attenuation(freqs, 20.0, 50.0, 101.325) son una temperatura, una humedad y una presión en un orden que no recuerda nadie, y bank.filter(x, True) no dice cuál de cinco banderas se ha activado.

El fallo es ruidoso, que es de lo que se trata:

import numpy as np

from phonometry.signals import leq

x = np.random.default_rng(1).standard_normal(4800) * 0.01

try:
    leq(x, 48000)
except TypeError as error:
    print(error)      # leq() takes 1 positional argument but 2 were given

Esa llamada merece una segunda mirada. leq nunca tuvo fs, porque una media energética no lo necesita, así que en la 3.3.0 el 48000 se ligaba en silencio a calibration_factor y la respuesta salía 93,6 dB alta sin una queja. Ahora es un TypeError, que es lo que siempre debió ser.

print(round(float(leq(x, dbfs=True)), 3))

Los nombres públicos se habían ido repartiendo entre varias grafías de la misma magnitud, y la 4.0 se queda con la que ya usaba la mayoría. La regla de las magnitudes que se cuentan en plural es la que seguía casi toda la API: un campo o un parámetro que guarda un array es frequencies, times, distances o levels, y uno que guarda un solo valor va en singular. Un argumento vectorizado que admite un número o un array conserva su nombre.

times, levels = decay_curve(ir, fs) sigue desempaquetando la curva de caída, en el mismo orden. Los solvers FDTD conservan c y rho, que nombran los mapas en los que están escritas sus ecuaciones.

El .plot() de cada resultado se lee ahora plot(ax=None, *, ...): primero los ejes, y todo lo demás por su nombre, language incluido. Tres no empezaban por los ejes en la 3.3.0, así que plot(ax) les entregaba los ejes al parámetro equivocado:

Seis resultados posteriores a la 3.3.0 tomaban language por posición en la 4.0.0rc1: las cuatro valoraciones de protectores auditivos y los dos resultados de intensimetría en baja frecuencia. plot(ax, "es") sobre ellos es ahora plot(ax, language="es"), como en todos los demás.

Las cinco funciones verify_* devolvían dict[str, Any] y ahora devuelven una dataclase congelada, como cualquier otro resultado de la biblioteca. Dos envoltorios públicos que existían sólo para empaquetar ese diccionario se fueron con el cambio, ya que el verificador devuelve ahora el objeto él mismo.

from phonometry.filters import OctaveFilterBank, verify_filter_class

verdict = verify_filter_class(OctaveFilterBank(48000, fraction=1, limits=[125, 4000]))
print(verdict.overall_class, len(verdict.bands))

verify_running_rms_decay es posterior a la 3.3.0, y en la 4.0.0rc1 devolvía un bool desnudo, que tiraba el intervalo impreso y el tiempo medido que había juzgado. Ahora devuelve un RunningRmsDecayVerification que conserva los dos: el veredicto es .passes, junto a .measured_time_s, .printed_time_s, .tolerance_s y el intervalo como .lower_time_s y .upper_time_s. El objeto se niega a leerse como valor de verdad, así que un if verify_running_rms_decay(...): escrito contra la versión candidata levanta TypeError en vez de dar por buenos todos los vibrómetros.

octave_filter() y OctaveFilterBank.filter() devolvían dos elementos normalmente y tres cuando sigbands=True pedía las señales por banda. La longitud de la respuesta dependía de una palabra clave, que es la razón por la que ese par necesitaba doce declaraciones @overload para poder tiparse, y por la que _, _, bands = bank.filter(...) era una línea en la que había que contar comas.

Ahora devuelven un OctaveFilterResult con campos con nombre, como cualquier otro cálculo de la biblioteca.

import numpy as np
from phonometry import filters

result = filters.octave_filter(np.zeros(8000) + 1e-6, 8000, fraction=3)
print(len(result.frequencies), result.bands)
# 25 None

bands es None salvo que la llamada haya pedido sigbands=True, y levels es None en una llamada hecha con calculate_level=False. El código que necesita cualquiera de los dos puede decirlo con require_bands() o require_levels(), que devuelven el valor o fallan nombrando el argumento que faltaba, en vez de entregar un None que revienta unas líneas más adelante.

El resultado también se dibuja solo, así que el espectro de bandas es una llamada:

ax = result.plot()

Una transformación a la que se le entrega un Signal devuelve un Signal desde que se escribió el contrato, pero cinco objetos de resultado todavía guardaban su forma de onda como un array desnudo junto a un fs suelto. Ahora conservan el tipo con el que llegó la entrada:

Un array desnudo sigue devolviendo un array desnudo, así que el código que pasa arrays no lo nota. El código que pasa un Signal y hace aritmética con uno de estos campos pasa por np.asarray, como con cualquier Signal, y una entrada calibrada vuelve con calibration_factor=1.0, así que el campo alimenta a la función siguiente en pascales sin que el factor se aplique otra vez.

io.read_blocks es posterior a la 3.3.0, y en la 4.0.0rc1 entregaba arrays float64 desnudos. Ahora entrega un Signal por bloque, con la frecuencia de muestreo, la calibración, las etiquetas de canal y la procedencia que da io.read, y toma el mismo calibration_factor= y lee el mismo sidecar. Para un bucle escrito contra la versión candidata cambian dos cosas. Un bloque de un archivo calibrado llega a los filtros y a las funciones de nivel en pascales, así que un calibration_factor aplicado a mano encima cuenta dos veces. Y la aritmética sobre un bloque, o sobre lo que un filtro devuelve para él, pasa por np.asarray, como con cualquier Signal.

Toda tabla que la biblioteca publica a nivel de módulo es de sólo lectura en la 4.0. En la 3.3.0 las tablas publicadas eran diccionarios corrientes y los arrays publicados admitían aritmética sobre el propio array, así que una línea como REFERENCE_CURVE[500] = 0.9 o BAND_IMPORTANCE *= 2 cambiaba el número para todo lo que se ejecutara después en el mismo proceso, sin que nada lo avisara. Los diccionarios son ahora types.MappingProxyType, también los que van anidados dentro de otra tabla, y los arrays tienen desactivada la bandera writeable. Leer no cambia; escribir lanza TypeError en una tabla y ValueError en un array.

El código que retocaba una tabla publicada tiene que copiarla antes:

from phonometry.materials.absorbers import REFERENCE_CURVE
from phonometry.speech.sii import BAND_IMPORTANCE

curve = dict(REFERENCE_CURVE)
curve[4000] = 1.0
weights = BAND_IMPORTANCE.copy()
weights[0] = 0.0
print(REFERENCE_CURVE[4000], curve[4000], weights[0], BAND_IMPORTANCE[0])
# 0.9 1.0 0.0 0.0083

Una tabla que lleva tablas dentro necesita copiar cada nivel, como en {area: dict(rows) for area, rows in GUIDE_VALUES.items()}. La misma copia hace falta antes de serializar una tabla con pickle, copiarla en profundidad o escribirla como JSON, porque un mapeo de sólo lectura no admite ninguna de las tres cosas.

En la 3.3.0 y en la 4.0.0rc1 un resultado guardaba el mismo array que se le pasaba siempre que ese array ya era del tipo que lee la función, float64 para niveles y frecuencias, porque en ese caso np.asarray devuelve su argumento sin tocarlo. Cambiar después el array de quien llamaba, levels[0] = 0.0 o frequencies *= 2, cambiaba un resultado ya calculado y quizá ya impreso. En la 4.0 todo array que una función o un método de la biblioteca guarda de los argumentos que recibe es una copia propia, de sólo lectura como las tablas publicadas, y el array de quien llama queda como estaba. Lo mismo vale para los objetos que guardan arrays para entregarlos después: la rejilla de frecuencias de una noise_control.SilencerChain, los ejes y las trayectorias con los que se construye una aircraft.AnpDatabase y los mapas del medio de simulation.FDTD2D y simulation.ElasticFDTD2D, cuyos c, rho, c_p y c_s siguen siendo ahora aquellos con los que se calculó el paso de tiempo. Una Signal también guarda una copia propia de sus muestras, que sigue siendo escribible para procesarla en su sitio, como siempre lo fueron las muestras de un fichero leído con io.read. Un registro de resultado construido a mano, llamando directamente a su clase, hace la misma copia: todo registro público que puede guardar un array copia los arrays que recibe al construirse, lo construya quien lo construya, también dentro de una tupla, una lista o cualquier diccionario. Un registro guardado dentro de otro se guarda entero y responde de sus propios arrays, y una Signal no es una excepción: los siete resultados que devuelven una forma de onda como Signal (filters.OctaveFilterResult, signals.EnvelopeResult, signals.ResampledSignalResult, signals.AlignedImpulseResponseResult, signals.SynchronousAverageResult, environment.DirectSoundSubtraction y underwater.PileStrikeResult) guardan una propia cuando los construye la biblioteca, cuyas muestras siguen siendo escribibles como las de cualquier Signal, y guardan la de quien llama cuando se construyen a mano con ella. Todos los demás arrays que guarda un resultado rechazan las escrituras en su sitio, tanto los que calculó como los que recibió, cuando en la 3.3.0 la mayoría de los calculados las aceptaban. Escribir en uno lanza ahora ValueError, así que el código que retocaba uno en su sitio tiene que copiarlo antes:

import numpy as np

from phonometry import io, room

levels = np.array([60.0, 58.0, 55.0, 52.0, 50.0, 48.0, 45.0, 42.0, 40.0, 38.0])
nc = room.noise_criterion(levels)
levels[0] = 0.0
samples = np.zeros(4)
signal = io.Signal(samples, fs=48_000)
samples[0] = 1.0
measured = np.array([1.0, 0.5, 0.25, 0.125])
response = room.ImpulseResponseResult(ir=measured, fs=48_000, method="farina")
measured[0] = 0.0
edited = nc.levels.copy()
edited[0] = 62.0
print(nc.levels[0], nc.levels.flags.writeable, response.ir[0], response.ir.flags.writeable)
print(signal.data[0, 0], signal.data.flags.writeable)
# 60.0 False 1.0 False
# 0.0 True

Los catálogos publicados de materiales son nuevos en la 4.0: ni la 3.3.0 ni la 4.0.0rc1 los tenían. Cambiaron de forma una vez de camino a la versión final, y el código escrito contra la rama principal entretanto necesita los cambios de abajo. Todas las filas de todos los catálogos comparten ahora una base, io.CatalogueRow (con io.BandedRow para una fila que imprime un valor por banda), y las mismas tres preguntas tienen la misma respuesta en cualquiera de ellas.

is_derived responde ahora sólo por lo que calcula la biblioteca y podría volver a calcular con las celdas de la propia fila, como una velocidad de barra obtenida de un módulo y una densidad. Un valor que la página da en otra unidad sigue siendo el número de la página, y también lo es uno que da por referencia a otra de sus filas, así que ninguno de los dos es ya derivado. basis_of responde con la entrada del propio campo, si no con la de la fila, y si no con una cadena vacía, que quiere decir que la fuente no dice cómo se obtuvo el número; las cinco cosas que puede afirmar una fuente están en io.CATALOGUE_BASES.

from phonometry import solids

board = solids.PUBLISHED_SOLIDS["hopkins-2007-table-a2/plasterboard_natural_gypsum"]
ear = solids.damping_named("EAR C-1002")[0]
print(board.basis_of("poisson_ratio"))
# estimated
print(ear.converted["youngs_modulus_max_pa"], ear.is_derived("youngs_modulus_max_pa"))
# ('3e5', 'psi') False

Las capas elásticas pasaron a ser filas de catálogo en el mismo cambio. Una ResilientLayer es una io.CatalogueRow como cualquier otra fila, con la clave y la atribución de las demás:

La Tabla A3 de Hopkins imprime $s^{\prime }$, la rigidez de la capa instalada tal como la define la lista de símbolos del propio libro, así que sus quince filas siguen guardando dynamic_stiffness_n_m3 y devuelven las frecuencias naturales que devolvían. Cuatro de ellas guardan una densidad que la página imprime una sola vez para su bloque y deja en blanco en su propia línea, y layer.carried["density_kg_m3"] nombra ahora la fila que la imprime; la densidad es la misma.

from phonometry import materials

rebond = materials.resilient_layer("hopkins-2007-table-a3/rebond_foam_64_20")
print(rebond.attributed_to["row"], round(rebond.natural_frequency(mass_per_area_kg_m2=120.0), 1))
# Hopkins and Hall (2006) 43.6

Toda fila de catálogo se comprueba en su constructor, la construya la biblioteca a partir de una tabla empaquetada o quien llama a mano, y una celda que nada de lo que viene después podría leer lanza io.CatalogueError, nombrando la fila y el campo. El código escrito entretanto contra la rama principal que contara con que se aceptara algo de lo siguiente tiene que cambiar:

Todas las demás filas empaquetadas cumplían ya el contrato, así que esas seis porosidades son las únicas celdas publicadas que cambian, y todas las filas porosas publicadas con los dos módulos imprimen su factor de pérdidas.

from phonometry import io, materials

try:
    materials.PorousMaterial(name="Panel core", source="a datasheet", porosity=97.0)
except io.CatalogueError as error:
    print(error)
# 'Panel core': porosity is 97.0, and a porosity is a fraction from 0 to 1

carpet = materials.Carpet(
    name="Loop pile", source="a datasheet", pile_height_mm=6.0, approximate=["pile_height_mm"]
)
print(carpet.approximate)
# frozenset({'pile_height_mm'})

verify_filter_class calificaba solo la máscara de la Tabla 1. Para la edición de 2014 califica ahora también la desviación del ancho de banda efectivo del 5.12 y la suma de las señales de salida del 5.16, calculadas como las calcula IEC 61260-2:2016, y la class de una banda y la overall_class del banco son la clase más estricta que se cumple en los tres. Para la edición de 1995 califica la respuesta integrada del filtro del 4.5.3 y la suma de las señales de salida del 4.9 junto a la Tabla 1, como las ensaya el capítulo 5 de esa edición. En las dos ediciones cada banda se califica a la frecuencia de entrada del banco hasta su mitad, así que una banda diezmada se califica sobre las imágenes que su diezmado pliega sobre ella, y el diezmador del banco las deja a más de 125 dB por debajo.

Los bancos de octavas y de tercios de octava siguen siendo clase 1.

from phonometry import filters

octave = filters.verify_filter_class(
    filters.OctaveFilterBank(48000, fraction=1, limits=[125, 4000]))
print(octave.overall_class, octave.requirement_class("relative_attenuation"))
# 1 1

Un veredicto llevaba antes como campo del constructor el límite con el que se le juzgaba. En 3.3.0 lo hacían tres: ToneAssessment.criterion_db, ExposureAssessment.action_value y limit_value, y RigidMassCalibrationResult.tolerance. Otros seis, posteriores a 3.3.0, lo hacían en 4.0.0rc1, y el resto de la tabla llegó después de 4.0.0rc1. Cualquier código que construyera uno a mano, o que lo reescribiera con dataclasses.replace, podía juzgar una medición contra cualquier número y seguir poniendo el nombre de la norma encima del resultado. En 4.0 todo límite que imprime una norma es una propiedad de solo lectura, leída de los campos que la seleccionan: las bandas, la condición, la fuente, la clase, la sala. Un veredicto que se guardaba junto a su límite se lee también de los campos medidos, o se contrasta con ellos al construir el resultado, de modo que no puede contradecir el límite. Las funciones que devuelven estos veredictos reciben los mismos argumentos y dan las mismas respuestas, y cada nombre de la tabla sigue leyendo el mismo valor; solo cambia el código que construye un veredicto directamente o que sustituye uno de estos campos. La última columna indica en qué versión apareció cada veredicto.

También cambian dos llamadas. rigid_mass_calibration_check ya no recibe tolerance: el apartado 7.5.2 de ISO 7626-2:2015 dice que el bloque «shall agree within ±5 %», así que una aceptación interna más estricta se lee de .deviation. Y HeavyImpactSourceCheck y RigidMassCalibrationResult, cuyo passes era un campo almacenado, se niegan a leerse como valor de verdad igual que los demás veredictos: if check: lanza TypeError y el veredicto es .passes.

import dataclasses

from phonometry import vibration

check = vibration.check_blocked_output([100.0, 200.0], [90.0, 95.0], [60.0, 70.0])
print(check.limit_db, check.passes)
# 20.0 True
try:
    dataclasses.replace(check, limit_db=10.0)
except TypeError as error:
    print(type(error).__name__)
# TypeError
calibration = vibration.rigid_mass_calibration_check([0.104, 0.093], [50.0, 500.0], 10.0)
print(calibration.tolerance, calibration.within_tolerance.tolist())
# 0.05 [True, False]

Los límites que una norma deja en manos del usuario siguen siendo campos: los límites de rugosidad y de tasa de decaimiento «por defecto» de ISO 3095, la tolerancia que ISO/DIS 16032 7.6 no imprime para «aproximadamente 30 s», el periodo de curado que fija la especificación del producto según ISO 10140-1 G.4, el desplazamiento de umbral que ISO 8253-1 deja aceptar al examinador, y los límites de especificación, de caso de ensayo y de fila de límites que se pasan a las comprobaciones de conformidad, de ISO 17534-1 y del RD 1367/2007. Los registros de requisitos de ISO 8297 y de IEC 60118-4, PlantRequirement y LoopRequirement, también conservan como campo el límite de cada fila: un mismo tipo de registro reúne requisitos cuyos límites mezclan cifras impresas con la geometría de la planta, la intensidad de campo especificada o el ruido medido con el bucle apagado.

La sección anterior sacó de los constructores los límites impresos. Las banderas del veredicto se quedaron dentro: passes, complies, qualified, todos los *_met y *_ok, los avisos y la clase de cada banda de un veredicto de filtro, de ponderación o de instrumento de intensidad. La función que construía el resultado las calculaba y las guardaba junto a las lecturas de las que salían, así que un resultado construido a mano, o reescrito con dataclasses.replace, podía guardar lecturas que no cumplen y una bandera que dice que sí. En 4.0 todas son propiedades de solo lectura, leídas de los valores que guarda el resultado y del límite que imprime la norma. El resultado conserva aquello de lo que se lee su veredicto: las lecturas, los márgenes, las posiciones, las cifras medidas. Una cifra que solo alimentaba el veredicto, como el nivel redondeado de un periodo del RD 1367/2007 o la fracción de gotas de lluvia dentro de su tolerancia, también es una propiedad. Las funciones que devuelven estos resultados reciben los mismos argumentos y dan los mismos veredictos, y cada nombre de la tabla sigue leyendo el mismo valor; solo cambia el código que construye uno de estos resultados directamente o que sustituye uno de los campos de la lista. «Solo por nombre» marca un campo que solo se pasa por nombre.

FilterComplianceResult y WeightingComplianceResult guardan sus filas por banda como band_margins: las filas que guardaba bands, sin la clave "class". Una fila que declara una clase se rechaza, y la propiedad bands añade a cada fila la clase que ganan sus márgenes, de modo que result.bands[i]["class"] se lee como antes. IntensityInstrumentComplianceResult ya no recibe filas por banda: guarda las frecuencias y el índice presión-intensidad residual medido, y lee de ellos, del dispositivo y de la separación de los micrófonos las filas, la clase y range_limited.

Las filas de las que se lee un veredicto son de solo lectura. band_margins y between_nominals se copian en diccionarios de solo lectura al construir el resultado, de modo que escribir en una lanza TypeError y escribir después en los diccionarios con los que se construyó no mueve la clase; para cambiar una fila, cópiela con dict(row), porque copy.deepcopy no puede copiar un diccionario de solo lectura. Las filas de AircraftSystemComplianceResult.checks, QuasiPeakDynamicsResult.stimuli y ReferenceTrackCheck.conditions se construyen, cada vez que se leen, a partir de lo que guarda el resultado y de las tablas de la norma.

import dataclasses

from phonometry import building, filters

gap = building.check_gap_width([5.0, 5.1, 5.2, 5.1])
print(gap.passes, round(gap.spread_mm, 1))
# True 0.2
try:
    dataclasses.replace(gap, passes=False)
except TypeError as error:
    print(type(error).__name__)
# TypeError
wider = dataclasses.replace(gap, readings_mm=(5.0, 5.1, 5.6, 5.1))
print(wider.uniform, wider.passes)
# False False
bank = filters.OctaveFilterBank(fs=48000, fraction=1, order=6, limits=[125, 4000])
result = filters.verify_filter_class(bank)
print(result.overall_class, result.bands[0]["class"], "class" in result.band_margins[0])
# 1 1 False

Una bandera sigue siendo un campo cuando no es un veredicto contra un límite y nada de lo que guarda el resultado la decide: una opción que fija quien llama, como small_room o noise_is_tonal; una rama que eligió quien llama con lo que pasó, como InverseSquareLawResult.origin_fitted; un hecho de una entrada que el resultado no guarda, como TimeWeightedEnvelope.calibrated; una propiedad del fichero leído; si un resolvedor iterativo convergió; y una columna de una fila de una tabla publicada. CriticalCouplingResult.converged conserva el desenlace de su resolución, que el resultado no puede repetir, pero ya no puede declarar la convergencia junto a una absorción que no supera 0,999, la tercera condición de la bandera. Un régimen que el resultado podría leer de sus propios valores es un veredicto, y la sección siguiente enumera los que se han movido. PlantRequirement y LoopRequirement no cambian: sus filas conservan cada límite como campo por la razón que da la sección anterior, y PlantRequirement.holds sigue junto a él. TrackCondition conserva su holds como fila del informe, pero ReferenceTrackCheck construye sus condiciones a partir de la vía que guarda, así que ningún veredicto lee una construida en otro sitio. También se quedan los checks de sí o no de SoundLevelMeterPeriodicRequirement: son lo que vio quien ensaya, una sobrecarga indicada o un indicador enclavado, no un límite juzgado.

Algunos resultados guardaban un régimen o una clasificación junto a los valores de los que se leía: el régimen de una válvula, si un martillo rebota, si el terreno apantalla un trayecto, si se encontró un tono, si un promediado síncrono tuvo que interpolar. La función comparaba valores que el resultado guarda, o podría guardar, con una constante o con un umbral que imprime su fuente, y guardaba la respuesta, así que un resultado construido a mano podía guardar la rigidez de un martillo en régimen subcrítico y decir que es sobrecrítico. En 4.0 cada una es una propiedad de solo lectura, leída de los valores que conserva el resultado, y un resultado que no conservaba lo que lee la prueba ahora lo conserva, con la unidad en el nombre. «Solo por nombre» marca un campo que solo se pasa por nombre.

Un valor justo en un límite cae donde lo pone la fuente. Hopkins imprime el caso sobrecrítico como K m ≥ 4 Zdp², así que el amortiguamiento crítico es sobrecrítico, e IEC TS 61400-11-2 pide un total «al menos 3 dB» por encima del fondo para la resta logarítmica, así que una diferencia de 3 dB la recibe. IEC 60534-8-4 no zanja su umbral de cavitación en un solo sentido: la prueba de 5.1 no deja el umbral mismo de ningún lado, la región de la Ecuación (9) y la Ecuación (19b) lo ponen con los puntos con cavitación, y 4.1, la Ecuación (18b) y 6.3 con los turbulentos. La biblioteca lo lee como turbulento, donde la Ecuación (9) devuelve cero y las dos ramas se encuentran sin escalón.

Las funciones reciben los mismos argumentos y devuelven los mismos números. Tiene que cambiar el código que construye uno de estos resultados directamente o que sustituye uno de los campos de los que se lee su régimen, y también el que lee band_type de vibration_reduction_index (véase debajo de la tabla).

building.VibrationReductionResult.band_type sigue siendo un campo, como el conjunto de bandas que declara quien llama: octave_bands() declara "octave", porque una sola banda de octava no se distingue de una de tercio de octava por su espaciado. vibration_reduction_index ya no lo rellena con el conjunto de bandas que leía de las frecuencias; lo deja en None, y el resultado lee el espaciado cada vez que calcula la media del anexo A, que da la misma media que antes.

Los números que elige un régimen quedan atados a él, así que un resultado construido a mano ya no puede llevar un régimen junto a los valores de otro. Al construirse, cada uno de estos resultados rechaza:

• TappingForceResult: una frecuencia de corte, una frecuencia límite, un espectro de fuerza o una potencia inyectada que no sean los que dan K, Zdp y m en su régimen, y unos límites de las ecuaciones (3.99) y (3.100) que no estén a un factor 2 el uno del otro.
• HydrodynamicValveNoise: una presión de vapor igual o superior a la presión de entrada; un x_F o un x_Fzp1 que no sean los que dan la Ecuación (1) o la (3c) a partir de los campos de al lado; un punto en la evaporación o más allá, x_F = 1; campos de cavitación en un punto turbulento, o ninguno en uno con cavitación.
• AerodynamicValveNoise: unos límites que no sean los de su gas y su guarnición, y un número de Mach o una eficiencia acústica de otro régimen.
• TerrainScreeningResult: una fuente o un receptor que no sean un punto finito, una fuente en el receptor o más allá, una sección que no vaya de uno al otro, y una diferencia de camino o unas aristas de difracción que no sean las de la goma elástica sobre esa sección.
• AutomaticThresholdResult y SweepThresholdResult: inversiones que no se alternan, un trazado que no conserva ningún pico o ningún valle, y una media, un umbral o un umbral continuo que no sean los que dan las inversiones.
• WaveMotionCorrection: una frecuencia más allá de la última fila de la tabla C.3, y una corrección que la tabla no da en su frecuencia.
• CabinInsulationResult: un aislamiento ponderado A con cualquier método que no sea el del ruido real.
• WindTurbineTonalityResult: una candidata que no sea una línea del espectro a 20 Hz o más, y una cadena de las fórmulas 30 a 34 que no sea la que da el espectro en torno a ella.
• LabJointInsulationResult: un índice corregido por otra regla de J.1.
• TurbineSoundLevels: una diferencia de niveles que no sea el total menos el fondo, un nivel del aerogenerador por otra regla de 11.7, y una incertidumbre en un intervalo cuyo nivel no se puede determinar.
• WestonPropagationResult: una pérdida compuesta que no sea la ley del régimen vigente.
• SynchronousAverageResult: una rejilla de periodo de más o menos muestras que round(fs * period_s).

import dataclasses

import numpy as np

from phonometry import building

bands = np.array([100.0, 200.0, 400.0, 800.0])
force = building.tapping_force_spectrum(bands, 1.0e6, 3.0e4)
print(force.over_critical)
# False
print(building.tapping_force_spectrum(bands, 1.0e6, 100.0).over_critical)
# True
try:
    dataclasses.replace(force, impedance=100.0)
except ValueError as error:
    print("cut_off_frequency" in str(error))
# True

Todo lo demás se movió. Estos diez no existen en ningún módulo público:

Los números. El informe de conformidad son las mismas 995 comprobaciones contra las mismas normas con los mismos valores esperados que tenía antes de la reorganización, y de cada renombrado de esta página se comprobó que devuelve lo que devolvía su predecesor. Si un resultado se mueve después de que termines de actualizar, eso es un defecto y merece la pena avisar.

Un veredicto es la excepción, y la sección sobre las clases de filtro de más arriba explica cómo: verify_filter_class califica el ancho de banda efectivo del 5.12 y la suma de salidas del 5.16 además de la máscara de la Tabla 1 para la edición de 2014, y la respuesta integrada del filtro del 4.5.3 y la suma del 4.9 con edition="1995", así que la clase de un banco es la más estricta que cumple en los tres. Cada banda se califica a la frecuencia de entrada del banco hasta la mitad de ella, así que los márgenes de la Tabla 1 de una banda diezmada recogen las imágenes que su diezmado pliega sobre ella.

Los bancos de filtros diezmados son la otra: cada banda conserva ahora su frecuencia de Nyquist de proceso en dieciséis veces su borde superior y diezma con un filtro antialiasing dimensionado para una banda atenuada de 120 dB, así que el nivel de una banda se mueve hasta 0,07 dB con ruido blanco, como dice la misma sección.

Lo que dibuja cada .plot() está intacto, y también lo que imprime cada .report() salvo una etiqueta: la ficha del micrófono escribe dB(468) donde escribía dB(CCIR). El contrato de Signal es el que era, ahora cumplido en dos sitios más, los bloques de read_blocks y las formas de onda dentro de cinco resultados. Cada fórmula está intacta también. La 4.0 recolocó los muebles y puso la unidad en la etiqueta; salvo esas dos, no recalculó nada.