From 6d7fcfd79bc635022e9260875d6ce31506a67f15 Mon Sep 17 00:00:00 2001 From: Kirby Heck Date: Wed, 11 Jun 2025 09:26:21 -0500 Subject: [PATCH 1/9] Adding custom Unified + TI for benchmarking with Curled wake model --- mitwindfarm/Rotor.py | 185 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) diff --git a/mitwindfarm/Rotor.py b/mitwindfarm/Rotor.py index f06fa08..5a92cb6 100644 --- a/mitwindfarm/Rotor.py +++ b/mitwindfarm/Rotor.py @@ -196,6 +196,67 @@ def __call__(self, x: float, y: float, z: float, windfield: Windfield, Ctprime, ) +class UnifiedAD_TI(UnifiedAD): + """ + Same as UnifiedAD but also accounts for a possible TI dependence + """ + + def __init__(self, rotor_grid=None, beta=0.1403, alpha=2.32, couple_x0=False): + """ + Initialize the UnifiedAD rotor model with the given axial induction factor. + + Parameters: + - beta (float): Axial induction factor (default is 0.1403). + - alpha (float): Turbulence intensity factor (default is 2.32, from Bastankhah and Porté-Agel 2016). + - couple_x0 (bool): If True, couples the x0 parameter to the pressure equation. Default is False. + """ + super().__init__(rotor_grid=rotor_grid) + if couple_x0: + self._model = UnifiedMomentumTI(beta=beta, alpha=alpha) + else: + self._model = UnifiedMomentumTI_x0(beta=beta, alpha=alpha) + + def __call__( + self, x: float, y: float, z: float, windfield: Windfield, Ctprime, yaw + ) -> RotorSolution: + """ + Calculate the rotor solution for given Ctprime and yaw inputs. + + Parameters: + - Ctprime (float): Thrust coefficient including the effect of yaw. + - yaw (float): Yaw angle of the rotor. + + Returns: + RotorSolution: The calculated rotor solution. + """ + + # Get the points over rotor to be sampled in windfield + xs_loc, ys_loc, zs_loc = self.rotor_grid.grid_points() + xs_glob, ys_glob, zs_glob = xs_loc + x, ys_loc + y, zs_loc + z + + # sample windfield and calculate rotor effective wind speed + Us = windfield.wsp(xs_glob, ys_glob, zs_glob) + TIs = windfield.TI(xs_glob, ys_glob, zs_glob) + + REWS = self.rotor_grid.average(Us) + RETI = np.sqrt(self.rotor_grid.average(TIs**2)) + sol = self._model(Ctprime, yaw, TI=RETI) + + # rotor solution is normalised by REWS. Convert normalisation to U_inf and return + return RotorSolution( + yaw, + sol.Cp[0] * REWS**3, + sol.Ct[0] * REWS**2, + sol.Ctprime, + sol.an[0] * REWS, + sol.u4[0] * REWS, + sol.v4[0] * REWS, + REWS, + TI=RETI, + extra=sol, + ) + + class BEM(Rotor): """ Blade Element Momentum (BEM) rotor model. Note: MITRotor is formulated in @@ -345,3 +406,127 @@ def __call__(self, x: float, y: float, z: float, windfield: Windfield, yaw) -> R TI=RETI, extra=None ) + + +# Custom momentum models - move to UnifiedMomentum later on +class UnifiedMomentumTI_x0(UnifiedMomentum): + """ + Here, the influence of TI on x0 is decoupled from the + other near-wake equations. + """ + + def __init__( + self, beta=0.1403, alpha=2.32, cached=True, v4_correction=1.0, **kwargs + ): + super().__init__( + beta=beta, cached=cached, v4_correction=v4_correction, **kwargs + ) + self.alpha = alpha + + def initial_guess(self, Ctprime, yaw, TI): + return super().initial_guess(Ctprime, yaw) + + def residual( + self, x: np.ndarray, Ctprime: float, yaw: float, TI: float = 0 + ): + """ + Returns the residuals of the Unified Momentum Model for the fixed point + iteration. The equations referred to in this function are from the + associated paper. + """ + return super().residual(x, Ctprime, yaw) # TI unused here; decoupled + + def post_process(self, result, Ctprime, yaw, TI): + a, u4, v4, _x0, dp = result.x + x0 = ( + np.cos(yaw) + / 4 + * (1 + u4) + * np.sqrt((1 - a) * np.cos(yaw) / (1 + u4)) + / (self.beta * np.abs(1 - u4) / 2 + self.alpha * TI) + ) # re-compute x0 with TI influence decoupled + result.x = (a, u4, v4, x0, dp) + return super().post_process(result, Ctprime, yaw) + + +class UnifiedMomentumTI(UnifiedMomentum): + """ + Extends the Unified Momentum Model to include a TI dependence + as described in Bastankhah and Porté-Agel (2016). + """ + def __init__(self, beta=0.1403, alpha=2.32, **kwargs): + super().__init__(beta=beta, **kwargs) + self.alpha = alpha + + def initial_guess(self, Ctprime, yaw, TI): + return super().initial_guess(Ctprime, yaw) + + def residual( + self, x: np.ndarray, Ctprime: float, yaw: float, TI: float = 0 + ): + """ + Returns the residuals of the Unified Momentum Model for the fixed point + iteration. The equations referred to in this function are from the + associated paper. + """ + an, u4, v4, x0, dp = x + if type(Ctprime) is float and Ctprime == 0: + return 0 - an, 1 - u4, 0 - v4, 100 - x0, 0 - dp + + p_g = self._nonlinear_pressure(Ctprime, yaw, an, x0) + + # Eq. 4 - Near wake length in residual form, includes alpha term. + e_x0 = ( + np.cos(yaw) + / 4 + * (1 + u4) + * np.sqrt((1 - an) * np.cos(yaw) / (1 + u4)) + / (self.beta * np.abs(1 - u4) / 2 + self.alpha * TI) + ) - x0 + + # Eq. 1 - Rotor-normal induction in residual form. + e_an = ( + 1 + - np.sqrt( + -dp / (0.5 * Ctprime * np.cos(yaw) ** 2) + + (1 - u4**2 - v4**2) / (Ctprime * np.cos(yaw) ** 2) + ) + ) - an + + # Eq. 2 - Streamwise outlet velocity in residual form. + e_u4 = ( + -(1 / 4) * Ctprime * (1 - an) * np.cos(yaw) ** 2 + + (1 / 2) + + (1 / 2) + * np.sqrt( + (1 / 2 * Ctprime * (1 - an) * np.cos(yaw) ** 2 - 1) ** 2 - (4 * dp) + ) + ) - u4 + + # Eq. 3 - Lateral outlet velocity in residual form. + e_v4 = ( + -self.v4_correction + * (1 / 4) + * Ctprime + * (1 - an) ** 2 + * np.sin(yaw) + * np.cos(yaw) ** 2 + - v4 + ) + + # Eq. 5 - Outlet pressure drop in residual form. + e_dp = ( + ( + -(1 / (2 * np.pi)) + * Ctprime + * (1 - an) ** 2 + * np.cos(yaw) ** 2 + * np.arctan(1 / (2 * x0)) + ) + + p_g + ) - dp + + return e_an, e_u4, e_v4, e_x0, e_dp + + def post_process(self, result, Ctprime, yaw, TI): + return super().post_process(result, Ctprime, yaw) From 1f9c7983ee41a1fd9667cf1bff1ba76c7c3c2c1e Mon Sep 17 00:00:00 2001 From: Kirby Heck Date: Wed, 11 Jun 2025 09:26:39 -0500 Subject: [PATCH 2/9] Adding numerics utilities for curled wake model marching --- mitwindfarm/utils/differentiate.py | 152 ++++++++++++++ mitwindfarm/utils/integrate.py | 306 +++++++++++++++++++++++++++++ 2 files changed, 458 insertions(+) create mode 100644 mitwindfarm/utils/differentiate.py create mode 100644 mitwindfarm/utils/integrate.py diff --git a/mitwindfarm/utils/differentiate.py b/mitwindfarm/utils/differentiate.py new file mode 100644 index 0000000..e2611b3 --- /dev/null +++ b/mitwindfarm/utils/differentiate.py @@ -0,0 +1,152 @@ +""" +Differentiation module + +Kirby Heck +2025 May 05 +""" + +import numpy as np +import warnings + + +def second_der( + arr, + dxi=None, + axis=-1, +): + """ + Computes the second derivative using second-order finite differences. + + Uses central differences for the interior and second-order forward/backward + differences for the boundaries. + + [Written by Gemini 2.5 Pro] + + Args: + arr (np.ndarray): Input array. + axis (int): The axis along which the derivative is taken. Default is -1. + dxi (float or array-like, optional): Spacing between points. + If None, spacing is assumed to be 1.0. + If a single float, it's used for the specified axis. + If an array-like, its length must be 1 or match arr.ndim. If it + matches arr.ndim, the spacing for the specified axis is used. + + Returns: + np.ndarray: The computed second derivative, same shape as arr. + + Raises: + ValueError: If dxi is array-like and its length doesn't match arr.ndim. + ValueError: If the array size along the specified axis is less than 2. + (Second-order boundaries require >= 4 points). + """ + arr = np.asarray(arr) + ndim = arr.ndim + # Ensure axis is positive for easier handling + positive_axis = axis if axis >= 0 else ndim + axis + if not (0 <= positive_axis < ndim): + raise np.AxisError(f"Invalid axis {axis} for array with {ndim} dimensions.") + + n = arr.shape[positive_axis] + + if dxi is None: + dx = 1.0 + else: + dxi = np.atleast_1d(dxi) + if len(dxi) == 1: + dx = float(dxi[0]) # Ensure float division + elif len(dxi) == ndim: + dx = float(dxi[positive_axis]) + else: + raise ValueError( + f"Length of dxi ({len(dxi)}) must be 1 or match the number of dimensions in arr ({ndim})." + ) + + if dx == 0: + raise ValueError("Spacing dx cannot be zero.") + + dx_sq = dx * dx + + # Initialize the result array + d2f_dx2 = np.zeros_like(arr, dtype=np.result_type(arr, dx)) # Match type + + # Handle edge cases for small arrays where second-order boundaries are not possible + if n < 2: + raise ValueError( + f"Array size {n} along axis {positive_axis} is too small to compute second derivative." + ) + elif n == 2: + # Cannot compute 2nd derivative meaningfully with only 2 points using these methods. + # np.gradient would give 0 for the 2nd derivative. Let's return 0. + warnings.warn( + f"Array size {n} along axis {positive_axis} is small; returning zeros for second derivative.", + stacklevel=2, + ) + return d2f_dx2 # Already zeros + elif n == 3: + # Can only compute central difference for the middle point + # Boundaries are problematic for 2nd order. + # Let's compute the middle point and leave boundaries as 0, with a warning. + warnings.warn( + f"Array size {n} along axis {positive_axis} is small; using central difference for interior point only, boundaries set to zero.", + stacklevel=2, + ) + f_im1 = np.take(arr, 0, axis=positive_axis) + f_i = np.take(arr, 1, axis=positive_axis) + f_ip1 = np.take(arr, 2, axis=positive_axis) + center_val = (f_ip1 - 2 * f_i + f_im1) / dx_sq + # Place the result in the correct slice of the output array + result_slice = [slice(None)] * ndim + result_slice[positive_axis] = 1 + d2f_dx2[tuple(result_slice)] = center_val + return d2f_dx2 + + # --- Main computation for n >= 4 --- + + # Interior points (central difference) + f_im1 = np.take(arr, np.arange(0, n - 2), axis=positive_axis) + f_i = np.take(arr, np.arange(1, n - 1), axis=positive_axis) + f_ip1 = np.take(arr, np.arange(2, n - 0), axis=positive_axis) + interior_val = (f_ip1 - 2 * f_i + f_im1) / dx_sq + + # Place the result in the correct slice of the output array + result_slice_interior = [slice(None)] * ndim + result_slice_interior[positive_axis] = slice(1, n - 1) + d2f_dx2[tuple(result_slice_interior)] = interior_val + + # Boundary point 0 (forward difference O(dx^2)) + # [2*f0 - 5*f1 + 4*f2 - f3] / dx^2 + f0 = np.take(arr, 0, axis=positive_axis) + f1 = np.take(arr, 1, axis=positive_axis) + f2 = np.take(arr, 2, axis=positive_axis) + f3 = np.take(arr, 3, axis=positive_axis) + start_val = (2 * f0 - 5 * f1 + 4 * f2 - f3) / dx_sq + + result_slice_start = [slice(None)] * ndim + result_slice_start[positive_axis] = 0 + d2f_dx2[tuple(result_slice_start)] = start_val + + # Boundary point N-1 (backward difference O(dx^2)) + # [2*f_{N-1} - 5*f_{N-2} + 4*f_{N-3} - f_{N-4}] / dx^2 + f_n1 = np.take(arr, n - 1, axis=positive_axis) + f_n2 = np.take(arr, n - 2, axis=positive_axis) + f_n3 = np.take(arr, n - 3, axis=positive_axis) + f_n4 = np.take(arr, n - 4, axis=positive_axis) + end_val = (2 * f_n1 - 5 * f_n2 + 4 * f_n3 - f_n4) / dx_sq + + result_slice_end = [slice(None)] * ndim + result_slice_end[positive_axis] = n - 1 + d2f_dx2[tuple(result_slice_end)] = end_val + + return d2f_dx2 + + +if __name__ == "__main__": + x = np.linspace(0, 2 * np.pi, 200, endpoint=False) + y = np.sin(x) * x + d2y_analytical = 2 * np.cos(x) - x * np.sin(x) + d2y = second_der(y, dxi=np.diff(x)[0], axis=0) + d2y_numpy = np.gradient(np.gradient(y, x), x) + print("Error in numerical vs analytical second derivative:") + print(np.max(np.abs(d2y - d2y_analytical))) + print("Numpy second derivative error:") + print(np.max(np.abs(d2y_numpy - d2y_analytical))) diff --git a/mitwindfarm/utils/integrate.py b/mitwindfarm/utils/integrate.py new file mode 100644 index 0000000..4d010ce --- /dev/null +++ b/mitwindfarm/utils/integrate.py @@ -0,0 +1,306 @@ +""" +IVP integration methods for Curled Wake Modeling + +Kirby Heck +2025 May 05 +""" + +import numpy as np +from scipy import integrate # import solve_ivp as solve_ivp_scipy + + +def rk4_step(t_n, u_n, dudt, dt): + """ + Computes the next timestep of u_n given the finite difference function du/dt + with a 4-stage, 4th order accurate Runge-Kutta method. + + Parameters + ---------- + t_n : float + time for time step n + u_n : array-like + condition at time step n + dudt : function + function du/dt(t, u) + dt : float + time step + + Returns u_(n+1) + """ + k1 = dt * dudt(t_n, u_n) + k2 = dt * dudt(t_n + dt / 2, u_n + k1 / 2) + k3 = dt * dudt(t_n + dt / 2, u_n + k2 / 2) + k4 = dt * dudt(t_n + dt, u_n + k3) + + u_n1 = u_n + 1 / 6 * (k1 + 2 * k2 + 2 * k3 + k4) + return u_n1 + + +def EF_step(t_n, u_n, dudt, dt): + """ + Simple forward Euler stepping scheme. + + Parameters + ---------- + t_n : float + time for time step n + u_n : array-like + condition at time step n + dudt : function + function du/dt(t, u) + dt : float + time step + + Returns u_(n+1) + """ + u_n1 = u_n + dt * dudt(t_n, u_n) + return u_n1 + + +METHODS = { + f"scipy_{key}".lower(): val for key, val in integrate._ivp.ivp.METHODS.items() +} +STEPS = { + "rk4": rk4_step, + "ef": EF_step, +} + + +def solve_ivp(dudt, T, u0, dt=0.1, f=rk4_step, end_exact=True, **kwargs): + """ + General integration function which calls a step function multiple times depending + on the parabolic integration strategy. + + Checks for two specific exceptions: + - IntegrationException: raised when the integration fails at a specific time step. + - DomainExpansionRequest: raised when the integration requests a domain expansion. + + Parameters + ---------- + dudt : function + Evolution function du/dt(t, u, ...) + T : (2, ) + Time range + u0 : array-like + Initial condition of values + dt : float + Time step + f : function + Integration stepper function (e.g. RK4, EF, etc.) + + Returns + ------- + t : (Nt, ) vector + Time vector + u(t) : (Nt, ...) array-like + Solution to the parabolic ODE. + """ + t = [] + ut = [] + + u_n = u0 # initial condition + t_n = T[0] + + ut.append(u_n) + t.append(t_n) + + keep_going = True + while keep_going: + # update timestep + t_n1 = t_n + dt + if t_n1 > T[1]: + if end_exact: + dt = T[1] - t_n # adjust the last step to end exactly at T[1] + if dt == 0: + break # avoid zero step size, not sure exactly how we get here + t_n1 = T[1] + keep_going = False + else: + break + + try: + u_n1 = f(t_n, u_n, dudt, dt) + except IntegrationException as e: + # re-raise with additional state information + raise IntegrationException( + "Integration failed at time step.", + partial_t=np.array(t), # save integration up to this point + partial_u=np.array(ut), + ) from e + except DomainExpansionRequest as e: + # re-raise with additional state information + e.partial_t = np.array(t) # save integration up to this point + e.partial_u = np.array(ut) + raise e + # raise DomainExpansionRequest( + # "Domain expansion requested during integration.", + # partial_t=np.array(t), + # partial_u=np.array(ut), + # expand_y=e.expand_y, + # expand_z=e.expand_z, + # ) from e + + # save solution + ut.append(u_n1) + t.append(t_n1) + + # update: + u_n = u_n1 + t_n = t_n1 + + return np.array(t), np.array(ut) + + +def solve_ivp_interrupt(dudt, T, u0, f=METHODS["scipy_rk45"], **options): + """ + Uses scipy's stepper functions but overrides the + default scipy solve_ivp to allow for interruptions and + custom Exception handling. + """ + + t0, tf = map(float, T) + try: + # for initializing the solver calls `dudt`, so this must be caught as well + solver = f(dudt, t0, np.atleast_1d(u0), t_bound=tf, **options) + except (DomainExpansionRequest, IntegrationException) as e: + e.partial_t, e.partial_u = [T[0]], u0 + raise e + + t = [solver.t] + ut = [solver.y] + + while solver.status == "running": + try: + message = solver.step() + except (DomainExpansionRequest, IntegrationException) as e: + e.partial_t = np.array(t) + e.partial_u = np.array(ut) + raise e + except Exception as e: + raise IntegrationException( + f"Integration failed during step: {e}", + partial_t=np.array(t), # save integration up to this point + partial_u=np.array(ut), + extra=str(e), + ) from e + + # append solution + t.append(solver.t) + ut.append(solver.y) + + return np.array(t), np.array(ut) + + +class Integrator: + def __init__(self, scheme="rk4"): + self.use_scipy = False + self.use_scipy_method = False + + if callable(scheme): + self.step_fn = scheme + + elif scheme.lower() in METHODS: + self.use_scipy = True + self.use_scipy_method = True + self.step_fn = METHODS[scheme.lower()] + + elif scheme.lower() in STEPS: + self.step_fn = STEPS[scheme.lower()] + + elif scheme.lower() == "scipy": + self.use_scipy = True + + else: + avail = ", ".join(sorted(METHODS.keys()) + list(STEPS.keys()) + ["scipy"]) + raise ValueError( + f"Unknown integration scheme: {scheme}, choose from {avail}" + ) + + def __call__(self, dudt, T, u0, **kwargs): + """Calls the integrator function""" + + if self.use_scipy_method: + _kwargs = dict(rtol=1e-4, max_step=0.5) # helps with stability + _kwargs.update(kwargs) + u0 = np.atleast_1d(u0) + shape = u0.shape + try: + t, y = solve_ivp_interrupt( + dudt, T, u0.flatten(), f=self.step_fn, **kwargs + ) + return t, y.reshape(len(t), *shape).squeeze() + except (DomainExpansionRequest, IntegrationException) as e: + e.partial_u = e.partial_u.reshape(len(e.partial_t), *shape).squeeze() + raise e + + elif self.use_scipy: + raise NotImplementedError( + "scipy deprecated because it does not allow for exception handling" + ) + + else: + return solve_ivp(dudt, T, u0, f=self.step_fn, **kwargs) + + +class IntegrationException(Exception): + """Custom exception for integration failures.""" + + def __init__( + self, + message, + partial_t=None, + partial_u=None, + extra=None, + ): + super().__init__(message) + self.partial_t = partial_t + self.partial_u = partial_u + self.message = message + self.extra = extra + + def __str__(self): + return self.message + + +class DomainExpansionRequest(Exception): + """Custom exception to signal a request for domain expansion.""" + + def __init__( + self, + message, + partial_t=None, + partial_u=None, + expand_y=None, + expand_z=None, + extra=None, + ): + super().__init__(message) + self.partial_t = partial_t + self.partial_u = partial_u + self.expand_y = expand_y + self.expand_z = expand_z + self.message = message + self.extra = extra + + def __str__(self): + return self.message + + +if __name__ == "__main__": + # Example usage: + # Define a simple ODE: du/dt = -u + def dudt(t, u): + # if u < 5e-2: + # raise IntegrationException("less than threshold") + return -u + + integrator = Integrator("scipy_rk45") + try: + time, solution = integrator(dudt, (0, 10), 1, dt=0.1, end_exact=True) + except IntegrationException as e: + time, solution = e.partial_t, e.partial_u + print("Time:", time[-1]) + print("Solution:", solution) + print(solution.squeeze().shape) + # Compare with analytical solution e^(-t) + print("Analytical Solution:", np.exp(-time)) From 04c6b267d00a68c72658a70c4e7ce481d168031d Mon Sep 17 00:00:00 2001 From: Kirby Heck Date: Wed, 11 Jun 2025 09:27:19 -0500 Subject: [PATCH 3/9] Adding working Curled Wake model code and new CurledWindFarm class --- mitwindfarm/CurledWake.py | 1018 +++++++++++++++++++++++++++++++++++++ mitwindfarm/windfarm.py | 54 ++ 2 files changed, 1072 insertions(+) create mode 100644 mitwindfarm/CurledWake.py diff --git a/mitwindfarm/CurledWake.py b/mitwindfarm/CurledWake.py new file mode 100644 index 0000000..e07beb1 --- /dev/null +++ b/mitwindfarm/CurledWake.py @@ -0,0 +1,1018 @@ +""" +Curled wake model solver in MITWindfarm. +(Now in a separate file) + +Kirby Heck +2025 June 6 +""" + +from abc import ABC, abstractmethod +from dataclasses import dataclass +from typing import Literal +from warnings import warn + +from numpy.typing import ArrayLike +import numpy as np +from scipy.signal import convolve2d +from scipy.interpolate import interpn, interp1d + +from mitwindfarm.Windfield import Windfield +from mitwindfarm.Rotor import RotorSolution +from mitwindfarm.utils.integrate import ( + Integrator, + IntegrationException, + DomainExpansionRequest, +) +from mitwindfarm.utils.differentiate import second_der + + +class CurledWakeWindfield(Windfield): + """ + Windfield for the curled wake model. This wind field HAS a base windfield + which represents the base flow, and then adds turbines on top of the base + windfield. + + The CurledWakeWindfield is also the flow solver/forward marching method + for the Curled Wake Model. It does the following: + - Applies initial conditions + - Manages the domain size, expanding as necessary + - Manages turbulence models + - Marches the wind field (and possibly other fields: dk, dv, dw) forward + in space + """ + + def __init__( + self, + base_windfield: Windfield, + integrator: str = "scipy_rk45", + ivp_kwargs: dict = None, + dx: float = 0.1, + dy: float = 0.1, + dz: float = 0.1, + ybuff: float = 3, + zbuff: float = 2, + N_vortex: int = 10, + sigma_vortex: float = 0.2, + smooth_fact: float = 1, + k_model: Literal["const", "k-l"] = "const", + k_kwargs: dict = None, + ic_method: Literal["du", "fx"] = "du", + clip_u: float = 0.1, + use_r4: bool = True, + auto_expand: bool = True, + verbose: bool = False, + ): + """ + Initialize the wind field with specified parameters. + + Parameters: + - base_windfield: The base wind field to be used. + - integrator: IVP solver to be used for the wind field (default: "scipy_rk45"). + see integrate.Integrator for options. + - ivp_kwargs: Additional arguments for the integrator (default: None). + - dx: Grid spacing in the x-direction, non-dim (default: 0.2). + - dy: Grid spacing in the y-direction, non-dim (default: 0.1). + - dz: Grid spacing in the z-direction, non-dim (default: 0.1). + - ybuff: Buffer in the y-direction (default: 3). + - zbuff: Buffer in the z-direction (default: 2). + - smooth_fact: Smoothing factor for the initial condition stencil (default: 1). + - N_vortex: Number of vortices to use for the dv, dw initial conditions (default: 10). + - sigma_vortex: radius for the vortex de-singularization (default: 0.2). + - k_model: Turbulence model to use (default: "k-l"). + - k_kwargs: Additional arguments for the turbulence model (default: None). + - ic_method: Method for initial condition stamping (default: "du"). + NOTE: "fx" is experimental and only solves for EF marching. + - clip_u: Whether to clip the u-velocity to prevent negative values (default: 0.1). + Set to <= 0 to disable clipping + - use_r4: Whether to use the r4 rotor radius for initial conditions (default: True). + - auto_expand: Whether to automatically expand the domain when needed (default: True). + - verbose: Prints debug information if True (default: False). + """ + self.base_windfield = base_windfield + self.integrator = Integrator(integrator) + self.ivp_name = integrator + self.ivp_kwargs = ivp_kwargs if ivp_kwargs is not None else dict() + self.dx, self.dy, self.dz = dx, dy, dz + self.N_vortex = N_vortex + self.sigma_vortex = sigma_vortex + + # The following will get initialized later in check_grid_init() + self.grid = None # list of [x, y, z] axes + self.du = None # solved du-field + self.dv = None # solved dv-field + self.dw = None # solved dw-field + self.dk = None # solved k_wake field + + if "scipy" not in self.ivp_name: + self.ivp_kwargs.setdefault("dt", self.dx) + + self.ybuff = ybuff + self.zbuff = zbuff + + self.extra_fx = None + self.ic_method = ic_method # "fx" DOES NOT WORK - ONLY USE "du" + + self.clip_u = clip_u + self.use_r4 = use_r4 + self.auto_expand = auto_expand + + self.verbose = verbose + + # Turbulence modeling + self.k_model = k_model # turbulence model to use (default: "k-l") + self.k_kwargs = k_kwargs if k_kwargs is not None else {} + self.k_module = CurledTurbulenceModel.get_model( + self.k_model, curledwake=self, **self.k_kwargs + ) + + self.smooth_fact = smooth_fact # smoothing factor for the IC stencil + self.turbines = [] + + def wsp(self, x: ArrayLike, y: ArrayLike, z: ArrayLike) -> ArrayLike: + self.march_to(x=x, y=y, z=z) # check that the forward marching is sufficient + + x = np.asarray(x) + y = np.asarray(y) + z = np.asarray(z) + x, y, z = np.broadcast_arrays(x, y, z) + + wsp_base = self.base_windfield.wsp(x, y, z) + wsp_wakes = interpn( + (self.grid[0], self.grid[1], self.grid[2]), + self.du, + (x.ravel(), y.ravel(), z.ravel()), + method="linear", + bounds_error=False, + fill_value=0, + ).reshape(x.shape) + wsp = wsp_base + wsp_wakes + return wsp + + def TI(self, x: ArrayLike, y: ArrayLike, z: ArrayLike) -> ArrayLike: + self.march_to(x=x, y=y, z=z) # check that the forward marching is sufficient + + x = np.asarray(x) + y = np.asarray(y) + z = np.asarray(z) + x, y, z = np.broadcast_arrays(x, y, z) + + ti_base = self.base_windfield.TI(x, y, z) + wsp_base = self.base_windfield.wsp(x, y, z) + + k_wake = interpn( + (self.grid[0], self.grid[1], self.grid[2]), + self.dk, + (x.ravel(), y.ravel(), z.ravel()), + method="linear", + bounds_error=False, + fill_value=0, + ).reshape(x.shape) + wsp = self.wsp(x, y, z) + ti = np.sqrt((wsp_base * ti_base) ** 2 + 2 * k_wake / 3) / wsp + return ti + + def wdir(self, x: ArrayLike, y: ArrayLike, z: ArrayLike) -> ArrayLike: + # TODO: FIX + return self.base_windfield.wdir(x, y, z) + + def march_to(self, x: float, y: float, z: float) -> None: + """ + March the wind field to the specified coordinates. + + Parameters: + - x: x-coordinate. + - y: y-coordinate. + - z: z-coordinate. + """ + self.check_grid_init(x=x, y=y, z=z) # check if the grid is initialized + self._march(xmax=np.max(x)) + + def stamp_ic( + self, + rotor_solution: RotorSolution, + xt, + yt, + zt, + smooth_fact=None, + D=1, + ) -> None: + """ + Stamp the initial condition of the rotor solution into the wind field. + + Parameters: + - rotor_solution: The rotor solution to stamp into the wind field. + - smooth_fact: Smoothing factor for the initial condition stencil. + - D: Diameter of the rotor (default: 1). + """ + # first, add the turbine to the list of turbines + self.turbines.append(TurbineProperties(xt, yt, zt, D, rotor_solution)) + + # adjust grid bounds if necessary + self.adjust_grid_bounds(x=None, y=yt, z=zt, add_buffers=True) + + # streamwise velocity initial condition: + smooth_fact = self.smooth_fact if smooth_fact is None else smooth_fact + rotor = rotor_solution + r4 = ( + np.sqrt((1 - rotor.extra.an) / rotor.extra.u4) * D / 2 + if self.use_r4 + else D / 2 + ) + ay = r4 * np.cos(rotor.yaw) + az = r4 # TODO: could factor in rotor tilt later on + shape = ic_stencil( + self.grid[1], + self.grid[2], + yt, + zt, + smooth_fact=smooth_fact, + ay=ay, + az=az, + ) + + if self.ic_method == "fx": + # NOTE: DO NOT USE + thrust = -rotor.Ct * 0.5 * np.pi / 4 + self.extra_fx += ( + shape * thrust / (np.sum(shape) * self.dy * self.dz * self.dx) + ) + warn( + "`fx` is not a reliable method for stamping initial conditions. Use `du` instead." + ) + else: + # stamp the rotor solution into the wind field + # TODO: check du is negative? + delta_u = rotor.u4 - rotor.REWS # delta_u, adjusted by REWS + self.du[-1, ...] += shape * delta_u + + # dv, dw initial conditions: + if rotor.yaw == 0: + return # no additional dv, dw to stamp in for this turbine + + # TODO: Put this in a separate module + # self.N_vortex = 10 # make this a parameter + # self.vortex_sigma = 0.2 # sigma/D, for de-singularization + + # r-axis: clip edges to prevent singularities + r_i = np.linspace(-(D - self.dz) / 2, (D - self.dz) / 2, self.N_vortex) + # NOTE: rotor.Ct differs from Shapiro et al. (2018) definition - includes cos^2(yaw) + Gamma_0 = 0.5 * D * rotor.REWS * rotor.Ct * np.sin(rotor.yaw) + Gamma_i = ( + Gamma_0 * 4 * r_i / (self.N_vortex * D**2 * np.sqrt(1 - (2 * r_i / D) ** 2)) + ) + + # generally, vortices can decay, so sigma should be a function of x # TODO + sigma = self.sigma_vortex * D + + # now we build the main summation, which is 3D (y, z, i) + yG, zG = np.meshgrid(self.grid[1], self.grid[2], indexing="ij") + yG = yG[..., None] + zG = zG[..., None] + rsq = (yG - yt) ** 2 + (zG - zt - r_i[None, None, :]) ** 2 # 3D grid variable + rsq = np.clip(rsq, 1e-8, None) # avoid singularities + + # put pieces together: + exponent = 1 - np.exp(-rsq / sigma**2) + summation = exponent / (2 * np.pi * rsq) * Gamma_i[None, None, :] + + # sum all vortices along last dim + v = np.sum(summation * (zG - zt - r_i[None, None, :]), axis=-1) + w = np.sum(summation * -(yG - yt), axis=-1) + self.dv[-1, ...] += v # stamp in dv + self.dw[-1, ...] += w # stamp in dw + + def adjust_grid_bounds( + self, + x: ArrayLike = None, + y: ArrayLike = None, + z: ArrayLike = None, + add_buffers: bool = True, + ) -> None: + """ + Expand the dimensions of the wind field to accommodate wake + expansion and additional turbines. + + A buffer of xbuff, ybuff, zbuff will be applied to points checked. + + Parameters: + - x: x-coordinates, optional + - y: y-coordinates, optional + - z: z-coordinates, optional + - add_buffers: whether to add buffers to the grid (default: True) + """ + if self.grid is None: + raise AttributeError("Grid not initialized") + + # check and possibly expand grid with zero-padding + yax, zax = self.grid[1], self.grid[2] + ypad, zpad = (0, 0), (0, 0) + if y is not None: + y = np.atleast_1d(y) + ymin = np.min(y) - self.ybuff * add_buffers + ymax = np.max(y) + self.ybuff * add_buffers + ypad_lower = np.arange(yax[0] - self.dy, ymin - self.dy, -self.dy)[::-1] + ypad_upper = np.arange(yax[-1] + self.dy, ymax + self.dy, self.dy) + # update y-grid + self.grid[1] = np.concatenate([ypad_lower, yax, ypad_upper]) + ypad = (len(ypad_lower), len(ypad_upper)) + + if z is not None: + z = np.atleast_1d(z) + zmin = np.min(z) - self.zbuff * add_buffers + zmax = np.max(z) + self.zbuff * add_buffers + zpad_lower = np.arange(zax[0] - self.dz, zmin - self.dz, -self.dz)[::-1] + zpad_upper = np.arange(zax[-1] + self.dz, zmax + self.dz, self.dz) + # update z-grid + self.grid[2] = np.concatenate([zpad_lower, zax, zpad_upper]) + zpad = (len(zpad_lower), len(zpad_upper)) + + # # now we need to pad the du, dv, dw fields + self.du = np.pad(self.du, ((0, 0), ypad, zpad), mode="constant") + self.dv = np.pad(self.dv, ((0, 0), ypad, zpad), mode="constant") + self.dw = np.pad(self.dw, ((0, 0), ypad, zpad), mode="constant") + self.dk = np.pad(self.dk, ((0, 0), ypad, zpad), mode="constant") + self.extra_fx = np.pad(self.extra_fx, (ypad, zpad), mode="constant") + + def check_grid_init( + self, x: ArrayLike = None, y: ArrayLike = None, z: ArrayLike = None + ) -> None: + """Initializes self.grid if it doesn't exist.""" + if self.grid is None: + # Initialize the grid if it doesn't exist. Automatically add buffers + self.grid = [ + np.atleast_1d(x), + np.arange(-self.ybuff, self.ybuff + self.dy, self.dy) + y, + np.arange(-self.zbuff, self.zbuff + self.dz, self.dz) + z, + ] + + self.du = np.zeros(self.shape) + self.dv = np.zeros(self.shape) + self.dw = np.zeros(self.shape) + self.dk = np.zeros(self.shape) + self.extra_fx = np.zeros(self.shape[1:]) + + def _march(self, xmax) -> None: + """ + Forward marches delta_u and delta_k fields. + Can also expand to march delta_v and delta_w fields, + but for now these are constant in x (except when additional + yawed wakes are stamped in with initial conditions). + + Returns + - None (updates grid and self.du, self.dv, self.dw in place) + """ + if xmax <= np.max(self.grid[0]): + return # nothing to compute! + + # for now, _v and _w (2D slices of dv, dw) do not evolve in space + _v = self.dv[-1, ...] # last slice of dv + _w = self.dw[-1, ...] + y = self.grid[1] + z = self.grid[2] + ybnd, zbnd = (0, 0), (0, 0) # initialize variables for bound checking + + def _step(x, _state): + """ + Step for all functions d()/dx. + In the standard curled wake model, this is just Delta_u, but + in more advanced modeling (Klemmer and Howland, 2025), this also + marches the k_wake field forward simultaneously. + + Because some integrators (e.g., scipy) require a 1D array, we may + to reshape arrays to compute derivatives, then pack them back + into a flattened array. + """ + if np.any(np.isnan(_state)): + raise IntegrationException( + f"nan value encountered in state at x={x:.3f}", + ) + + # parse inputs from current state + _u, _k = self.k_module.unpack_inputs(_state) + _u = np.clip(_u, None, 0) # no positive velocity deficits... for now + + # ======== check state bounds for domain expansion ======== + if self.auto_expand: + check_yz = [] + check_yz.append(check_state_bounds(_u, thresh=1e-4)) + check_yz.append(check_state_bounds(_k, thresh=1e-6)) + if np.any([check_yz]): + # if any of the checks fail, we need to expand the domain along those dimensions + ybnd, zbnd = np.max(check_yz, axis=0) + raise DomainExpansionRequest( + f"Expanding domain at {x=:.2f}", expand_y=ybnd, expand_z=zbnd + ) + + # ========= assemble variables and fields ========= + # Full velocity fields for advection: + wsp = self.base_windfield.wsp(x, y[:, None], z[None, :]) + wdir = self.base_windfield.wdir(x, y[:, None], z[None, :]) + # compute k_base: assume TI = sqrt(2/3 k)/U + kb = (self.base_windfield.TI(x, y[:, None], z[None, :]) * wsp) ** 2 * 3 / 2 + u = _u + wsp * np.cos(wdir) + v = _v + wsp * np.sin(wdir) + w = _w + 0 + k = _k + kb + + if (self.clip_u > 0) and np.any(u < self.clip_u): + u = np.clip(u, self.clip_u, None) + + self.k_module.update_wake_fields(u, v, w, k, _u, _v, _w, _k) + nu_T = self.k_module.nu_T(x) + + # ============== du/dx computation ============== + # gradient fields of \Delta u: + dudy = np.gradient(_u, y, axis=0) + dudz = np.gradient(_u, z, axis=1) + d2udy2 = second_der(_u, self.dy, axis=0) + d2udz2 = second_der(_u, self.dz, axis=1) + dudx = (-v * dudy - w * dudz + nu_T * (d2udy2 + d2udz2) + self.extra_fx) / u + + self.extra_fx *= 0 # reset extra forces after they are used - TODO: remove + + # ============== dk/dx computation ============== + dkdx = self.k_module.compute_dkdx() + + ret = self.k_module.pack_outputs(dudx, dkdx) + return ret + + # use last slice as initial condition, turbulence model may update IC + ic = self.k_module.update_ic(self.du[-1, ...]) + + try: + x, ret = self.integrator( + _step, [self.grid[0].max(), xmax], ic, **self.ivp_kwargs + ) + except IntegrationException as e: + x = e.partial_t + ret = e.partial_u + if self.verbose: + print( + f"IntegrationException, exiting integration at x={max(x)}:\n\t", + e, + ) + except DomainExpansionRequest as e: + x = e.partial_t + ret = e.partial_u + ybnd = e.expand_y + zbnd = e.expand_z + # every time we get here, expand the expansion... + if np.any(ybnd): + self.ybuff += 1 + if np.any(zbnd): + self.zbuff += 1 + + if len(x) > 1: + # append and concatenate progress + du_new, dk_new = self.k_module.unpack_outputs(ret) + dv_new = np.repeat(self.dv[-1][None, ...], len(x) - 1, axis=0) + dw_new = np.repeat(self.dw[-1][None, ...], len(x) - 1, axis=0) + + self.du = np.concatenate([self.du, du_new[1:, ...]], axis=0) + self.dv = np.concatenate([self.dv, dv_new], axis=0) + self.dw = np.concatenate([self.dw, dw_new], axis=0) + self.dk = np.concatenate([self.dk, dk_new[1:, ...]], axis=0) + self.grid[0] = np.concatenate([self.grid[0], x[1:]]) + + # if we hit a DomainExpansionRequest, need to expand the grid and continue integrating + if np.any([ybnd, zbnd]): + if self.verbose: + print(f"Expanding grid at x={np.max(x):.2f} in y={ybnd} and z={zbnd}") + + self.adjust_grid_bounds( + y=[y[0] - ybnd[0] * self.ybuff, y[-1] + ybnd[1] * self.ybuff], + z=[z[0] - zbnd[0] * self.zbuff, z[-1] + zbnd[1] * self.zbuff], + add_buffers=False, + ) + self._march(xmax=xmax) # recursive call to continue marching + + @property + def shape(self) -> tuple[int, int, int]: + """ + Returns the shape of the grid. + """ + return (len(self.grid[0]), len(self.grid[1]), len(self.grid[2])) + + +@dataclass +class TurbineProperties: + """ + Class to hold turbine properties. + """ + + xt: float + yt: float + zt: float + D: float + rotor_solution: RotorSolution + + +# =========================================================================== +# ======================== TURBULENCE MODELING ============================== +# =========================================================================== + + +class CurledTurbulenceModel(ABC): + """ + Base class for the turbulence model in the curled wake model. + + Keeps track of all sub-classes with a self-registering factory. + """ + + _registry = {} + name: str # fill this in for each model + + def __init__(self, curledwake: CurledWakeWindfield): + self.curledwake = curledwake # link to the curled wake solver object + self.need_reshape = False + + def __init_subclass__(cls, **kwargs): + """ + This special method is called when a subclass is created. + It registers the subclass in the turbulence model registry. + """ + super().__init_subclass__(**kwargs) + if hasattr(cls, "name"): + cls._registry[cls.name] = cls + else: + raise ValueError(f"Subclass {cls.__name__} must define a 'name' attribute.") + + @classmethod + def get_model(cls, name: str, *args, **kwargs): + """ + Factory method to get an instance of a turbulence model. + """ + model_class = cls._registry.get(name) + if not model_class: + raise ValueError( + f"Unknown turbulence model: '{name}'. " + f"Available models: {list(cls._registry.keys())}" + ) + return model_class(*args, **kwargs) + + @abstractmethod + def nu_T(self, x): + """ + Returns nu_T, the eddy viscosity for the turbulence model + """ + ... + + def update_ic(self, ic): + """ + Update the initial condition for the turbulence model + """ + return ic + + def unpack_inputs(self, state): + """ + Unpack inputs for the forward marching u^n and possibly k^{n+1} + + Returns: + - du: wake deficit + - dk: k_wake field (default is 0) + """ + if state.ndim == 1: + self.need_reshape = True # we will need this in packing the outputs + state = state.reshape(self.curledwake.shape[1:]) + return state, np.zeros_like(state) + + def pack_outputs(self, dudx, dkdx): + """ + Pack outputs for the forward marching dudx and possibly dkdx + """ + if self.need_reshape: + dudx = dudx.flatten() + return dudx + + def unpack_outputs(self, ret): + """ + Unpack the output result of the forward marching + """ + return ret, np.zeros_like(ret) # default: no k_wake field + + def compute_dkdx(self): + """ + Computes the dk/dx term for the turbulence model. + """ + return None # by default, this is not needed + + def update_wake_fields(self, u, v, w, k, du, dv, dw, dk): + """ + Update the wake fields for the turbulence model. + """ + pass # by default, these are not needed + + def __repr__(self): + return f"CurledTurbulenceModel: {self.__class__.__name__}" + + +class CurledTurbulenceModel_const(CurledTurbulenceModel): + """ + Constant eddy viscosity model for the curled wake model. + """ + + name = "const" + + def __init__(self, curledwake, nu_T=1e-3, **kwargs): + """ + Initializes a constant eddy viscosity model with fixed model parameters. + """ + super().__init__(curledwake=curledwake) + self.nu_eff = nu_T + + def nu_T(self, x): + """ + Returns the constant eddy viscosity. + """ + return self.nu_eff + + +class CurledTurbulenceModel_2021(CurledTurbulenceModel): + """ + Curled wake turbulence model from Martínez-Tossas et al. (2021) WES paper + + Uses an ABL mixing length model proposed by Blackadar (1962) + """ + + name = "2021" + + def __init__( + self, + curledwake, + C: float = 4, + lam: float = None, + Ro: float = None, + kappa: float = 0.4, + ): + """ + Initializes the turbulence model. Note that all variables must + be non-dimensionalized or otherwise consistent with the + curled wake solver. + + Parameters: + - curledwake: The curled wake solver + - C: Constant for the turbulence model (default: 4) + - lam: Mixing length, non-dimensionalized (default: None) + - Ro: Turbine diameter-based rossby number G/(f_c * D) (default: None) + - kappa: von Karman constant (default: 0.4) + """ + super().__init__(curledwake=curledwake) + self.C = C + self.Ro = Ro + self.kappa = kappa + if Ro is not None: + self.lam = 0.00027 * Ro # lam/D + elif lam is not None: + self.lam = lam + else: + raise AttributeError( + "Either `lam` or `Ro` must be provided to the turbulence model." + ) + + def nu_T(self, x): + """ + Computes Eq. 13 in Martínez-Tossas et al. (2021) + + Note that as the baseflow may vary as a function of x, y, z, + dU/dz is computed at the current x, y, z locations. + """ + yg, zg = np.meshgrid( + self.curledwake.grid[1], self.curledwake.grid[2], indexing="ij" + ) + U = self.curledwake.base_windfield.wsp(x, yg, zg) + dUdz = np.gradient(U, self.curledwake.dz, axis=-1) + lmix = self.kappa * zg / (1 + self.kappa * zg / self.lam) + lmix = np.clip(lmix, 1e-2, None) # mixing length must be non-negative + + return self.C * lmix**2 * np.abs(dUdz) + + +class CurledTurbulenceModel_kl(CurledTurbulenceModel): + """ + Class for the k-l turbulence model in the curled wake model. + + See Klemmer and Howland, JRSE (2025) for details and derivation. + """ + + name = "k-l" + + def __init__(self, curledwake, C_nu=0.04, C_k1=1, C_k2=1): + """ + Initializes a k-l turbulence model with fixed model parameters. + + Parameters + - curledwake: The curled wake solver + - C_nu: Constant for the eddy viscosity (default: 0.04) + - C_k1: transport term coefficient (default: 1) + - C_k2: dissipation term coefficient (default: 1) + """ + super().__init__(curledwake=curledwake) + self.C_nu = C_nu + self.C_k1 = C_k1 + self.C_k2 = C_k2 + self.nu_T_cached = 0 + self.dk = None # we will save this field from parsing inputs + self.u, self.v, self.w, self.k = None, None, None, None + self.du, self.dv, self.dw, self.dk = None, None, None, None + + def update_ic(self, ic): + """ + Stacks the k_wake field to the initial condition for the forward marching. + """ + return np.stack([ic, self.curledwake.dk[-1, ...]], axis=-1) + + def update_wake_fields(self, u, v, w, k, du, dv, dw, dk): + """ + Update the wake fields for the turbulence model. + """ + self.u = u + self.v = v + self.w = w + self.k = k + self.du = du + self.dv = dv + self.dw = dw + self.dk = dk + + def nu_T(self, x): + """ + Computes Eq. 6 in Klemmer and Howland (2025) + """ + lmix = interpolate_lmix(self.du, self.curledwake.grid[1])[:, None] + if np.any(lmix <= 0): + raise IntegrationException("lmix is non-positive") + + heaviside = get_heaviside(x, self.curledwake.grid[1], self.curledwake.turbines)[ + :, None + ] + self.nu_T_cached = self.C_nu * ( + (1 - heaviside) * np.sqrt(np.clip(self.k - self.dk, 0, None)) * 1 + + heaviside * np.sqrt(np.clip(self.k, 0, None)) * lmix + ) + return self.nu_T_cached + + def compute_dkdx(self): + """ + Computes the dk/dx term for the turbulence model. + """ + y = self.curledwake.grid[1] + z = self.curledwake.grid[2] + nu_T = self.nu_T_cached + lmix = interpolate_lmix(self.du, y)[:, None] + if np.any(lmix <= 0): + raise IntegrationException("lmix is non-positive") + + # transport equation for k_wake, written in parabolic form: + dkdx = ( + -self.v * np.gradient(self.dk, y, axis=0) + - self.w * np.gradient(self.dk, z, axis=1) + + nu_T + * ( + np.gradient(self.du, y, axis=0) * np.gradient(self.u, y, axis=0) + + np.gradient(self.du, z, axis=1) * np.gradient(self.u, z, axis=1) + ) + + self.C_k1 # pull out of gradient as C_k1 is constant + * ( + np.gradient(nu_T * np.gradient(self.dk, y, axis=0), y, axis=0) + + np.gradient(nu_T * np.gradient(self.dk, z, axis=1), z, axis=1) + ) + # need np.clip for the sqrt here + - self.C_k2 * (np.clip(self.dk, 0, None) ** (3 / 2) / lmix) + ) / self.u + return dkdx + + def unpack_inputs(self, state): + """ + Returns: + - du: wake deficit + - dk: k_wake field + """ + if state.ndim == 1: + self.need_reshape = True # we will need this in packing the outputs + state = state.reshape(self.curledwake.shape[1:] + (2,)) + + self.dk = state[..., 1] + return state[..., 0], state[..., 1] + + def pack_outputs(self, dudx, dkdx): + """ + Pack outputs for the forward marching dudx, dkdx + """ + ret = np.stack([dudx, dkdx], axis=-1) + if self.need_reshape: + return ret.flatten() + else: + return ret + + def unpack_outputs(self, ret): + """ + Unpack the output result of the forward marching + """ + return ret[..., 0], ret[..., 1] + + +def check_state_bounds(state, thresh=1e-4): + """ + Check values of 2D array `state` at the boundaries to see + if a domain expansion is needed. + """ + max_y = np.max(abs(state[[0, -1], :]), axis=1) + max_z = np.max(abs(state[:, [0, -1]]), axis=0) + + expand_y = max_y > thresh + expand_z = max_z > thresh + + return expand_y, expand_z + + +def ic_stencil(y, z, yt, zt, smooth_fact=1, ay=0.5, az=None) -> np.ndarray: + """ + Stencil for turbine initial condition. This is a 2D Gaussian kernel that is + convolved with an indicator function. + + Parameters: + - y: y-coordinates. + - z: z-coordinates. + - smooth_fact: Smoothing factor for the initial condition stencil. + - ay: Width of the stencil in the y-direction (default: 0.5). + - az: Width of the stencil in the z-direction (default: ay). + """ + az = ay if az is None else az + + yG, zG = np.meshgrid(y, z, indexing="ij") + dy = y[1] - y[0] + dz = z[1] - z[0] # assume these are equally spaced axes + kernel_y = np.arange(-10, 11)[:, None] * dy + kernel_z = np.arange(-10, 11)[None, :] * dz + + # turb = ((yG - yt) ** 2 + (zG - zt) ** 2) < R**2 + turb = (((yG - yt) / ay) ** 2 + ((zG - zt) / az) ** 2) < 1.0 + gauss = np.exp( + -(kernel_y**2 + kernel_z**2) / (np.sqrt(dy * dz) * smooth_fact) ** 2 / 2 + ) + gauss /= np.sum(gauss) # make sure this is normalized to 1 + return convolve2d(turb, gauss, "same") + + +def get_wake_bounds_y(du, thresh=0.05, relative=True): + """ + Parse wake bounds from the 2D du field, returns indices for + all crossings of threshold `thresh` from the wake profile in y. + + Parameters: + - du: 2D array of delta_u + - thresh: threshold for wake bounds + - relative: whether to use a threshold relative to max(abs(du)) + + Returns: + - ycross: array of y-crossings, arranged as [2 x N] array of (lower, upper) index pairs + """ + + du_y = np.max(abs(du), axis=1) + + _thresh = thresh * np.max(du_y) if relative else thresh + + ycross_lower = np.where((du_y[:-1] < _thresh) & (du_y[1:] >= _thresh))[0] + ycross_upper = np.where((du_y[:-1] > _thresh) & (du_y[1:] <= _thresh))[0] + ycross = np.vstack([ycross_lower, ycross_upper]) + + return ycross + + +def get_wake_bounds_z(du, thresh=0.05, relative=True): + """ + Parse wake bounds from the 2D du field, returns indices for + all crossings of threshold `thresh` from the wake profile in z. + + Parameters: + - du: 2D array of delta_u + - thresh: threshold for wake bounds + - relative: whether to use a threshold relative to max(abs(du)) + + Returns: + - zcross: array of z-crossings, arranged as [2 x N] array of (lower, upper) index pairs + """ + + du_z = np.max(abs(du), axis=0) + + _thresh = thresh * np.max(abs(du)) if relative else thresh + + zcross_lower = np.where((du_z[:-1] < _thresh) & (du_z[1:] >= _thresh))[0] + zcross_upper = np.where((du_z[:-1] > _thresh) & (du_z[1:] <= _thresh))[0] + zcross = np.vstack([zcross_lower, zcross_upper]) + + return zcross + + +def interpolate_lmix(du, y, method="nearest", fill_value=1.0, max_value=None, pad=True): + """ + Interpolates the mixing length scale from the du field. + + Parameters: + - du: 2D array of delta_u + - y: y-coordinates + + Returns: + - lmix: 1D array of mixing length scale + """ + if np.any(np.isnan(du)): + raise ValueError("du contains NaN values") + + if pad: + # zero-pad wake_bnds to ensure it goes to zero on both sides + wake_bnds = get_wake_bounds_y(np.pad(du, (1, 1), mode="constant")) + y_pad = np.pad(y, (1, 1), mode="edge") + y_bounds = y_pad[wake_bnds] + else: + wake_bnds = get_wake_bounds_y(du) + y_bounds = y[wake_bnds] + + if y_bounds.size == 0: + return np.full_like(y, fill_value) + + y_mean = np.mean(y_bounds, axis=0) + y_width = np.diff(y_bounds, axis=0).flatten() + f = interp1d( + y_mean, + y_width, + kind=method, + fill_value=(y_width[0], y_width[-1]), + bounds_error=False, + ) + if max_value is None: + return f(y) + else: + return np.clip(f(y), None, max_value) + + +def get_heaviside(x, yax, turbines, default_x0=1): + """ + Computes the heaviside function, which is 1 in the far-wake and 0 in the near-wake. + """ + ret = np.zeros_like(yax) + for t in turbines: + try: + x0 = t.rotor_solution.extra.x0 + if x0 == np.inf: + x0 = default_x0 + except AttributeError: + x0 = default_x0 + + if x >= t.xt and x < t.xt + x0: + # yids = (yax >= (t.yt - t.D/2)) & (yax <= (t.yt + t.D/2)) + # ret[yids] = 1 + ret += np.exp(-((yax - t.yt) ** 2) / 2 / (t.D / 2) ** 2) + + ret = np.clip(ret, 0, 1) + + return 1 - ret + + +def example(): + import matplotlib.pyplot as plt + from mitwindfarm import Uniform, Layout + from mitwindfarm.Plotting import plot_windfarm + from mitwindfarm.windfarm import CurledWindfarm + from mitwindfarm.Rotor import UnifiedAD_TI + import time + + time_st = time.time() + base_windfield = Uniform(TIamb=0.05) # 5% ambient TI + wf = CurledWindfarm( + rotor_model=UnifiedAD_TI(), + base_windfield=base_windfield, + solver_kwargs=dict( + dy=1 / 10, + dz=1 / 10, + integrator="scipy_rk23", # see + k_model="k-l", # alternatives: "const", "2021" + verbose=False, + ), + ) + layout = Layout([0, 5, 10], [0, 0.4, 0.8], [0, 0, 0]) + setpoints = [ + (2, np.radians(30)), + (2, np.radians(15)), + (2, 0), + ] # Example setpoints for two turbines + sol = wf(layout, setpoints) + print(f"Windfarm solution in {time.time() - time_st:.2f} seconds") + + fig, axs = plt.subplots( + figsize=(4, 4), nrows=2, ncols=1, sharex=True, height_ratios=(1, 2) + ) + plot_windfarm(sol, ax=axs[0], pad=2, axis=True) + axs[0].set_xlabel("$x/D$") + axs[0].set_ylabel("$y/D$") + # plot power per turbine + axs[1].bar(layout.x, [r.Cp for r in sol.rotors], width=2) + axs[1].set_ylabel("$C_P$") + axs[1].set_xticks(layout.x) + axs[1].set_xticklabels(np.arange(len(layout.x)) + 1) + axs[1].set_xlabel("Turbine row") + + plt.savefig("./test_twoturbine_curl.png", bbox_inches="tight") + + +if __name__ == "__main__": + example() diff --git a/mitwindfarm/windfarm.py b/mitwindfarm/windfarm.py index 779a090..976b322 100644 --- a/mitwindfarm/windfarm.py +++ b/mitwindfarm/windfarm.py @@ -7,6 +7,7 @@ from .Rotor import Rotor, AD, RotorSolution from .Windfield import Windfield, Uniform from .Wake import WakeModel, Wake, GaussianWakeModel +from .CurledWake import CurledWakeWindfield from .Superposition import Superposition, Niayifar @@ -142,3 +143,56 @@ def from_partial(self, partial: PartialWindfarmSolution) -> WindfarmSolution: def from_dict(self, partial: dict) -> WindfarmSolution: return self.from_partial(PartialWindfarmSolution.from_dict(partial)) + + +class CurledWindfarm(Windfarm): + """ + Curled Wake model wind farm solver. This solver needs a slightly different + __call__ method because there are no "wakes" or "wake superposition" in the + Curled Wake model. The wind farm is solved in a single step by numerically + integrating a parabolic PDE. + + Follows the general framework of Martínez-Tossas et al. (2019, 2021). + """ + + def __init__( + self, + rotor_model: Optional[Rotor] = None, + base_windfield: Optional[Windfield] = None, + TIamb: float = None, + solver_kwargs: Optional[dict] = None, + ): + """ + Initializes the CurledWindFarm. + + Note that TIamb is unused. Instead, ensure that the `base_windfield` + includes ambient turbulence. + """ + self.rotor_model = AD() if rotor_model is None else rotor_model + self.base_windfield = ( + Uniform(TIamb=TIamb) if base_windfield is None else base_windfield + ) + self.TIamb = TIamb + self.solver_kwargs = dict() if solver_kwargs is None else solver_kwargs + + def __call__( + self, layout: Layout, setpoints: list[tuple[float, ...]] + ) -> WindfarmSolution: + """ + Solves for the rotor solutions in the wind farm layout, marching + the CurledWakeWindfield to each rotor location as necessary. + """ + # this function has to: 1) arrange rotors to march downstream, 2) initialize the CurledWakeWindfield, 3) solve, 4) aggregate results + N = layout.x.size + wakes = N * [None] # this just remains as [None, ...] in CWM + rotor_solutions = N * [None] + + windfield = CurledWakeWindfield(self.base_windfield, **self.solver_kwargs) + + for i, (x, y, z) in layout.iter_downstream(): + windfield.march_to(x=x, y=y, z=z) # march to the next rotor location, extrapolating where necessary + rotor_solutions[i] = self.rotor_model(x, y, z, windfield, *setpoints[i]) + rotor_solutions[i].idx = i + windfield.stamp_ic(rotor_solutions[i], x, y, z) # stamp the rotor solution into the windfield + + return WindfarmSolution(layout, setpoints, rotor_solutions, wakes, windfield) From 453219f4e2679563d339414ff378ed90cc605ad8 Mon Sep 17 00:00:00 2001 From: Kirby Heck Date: Wed, 11 Jun 2025 09:46:13 -0500 Subject: [PATCH 4/9] moved curled wake example to ./examples/ --- examples/example_08_curled_windfarm.py | 69 ++++++++++++++++++++++++++ mitwindfarm/CurledWake.py | 48 +----------------- 2 files changed, 70 insertions(+), 47 deletions(-) create mode 100644 examples/example_08_curled_windfarm.py diff --git a/examples/example_08_curled_windfarm.py b/examples/example_08_curled_windfarm.py new file mode 100644 index 0000000..381995d --- /dev/null +++ b/examples/example_08_curled_windfarm.py @@ -0,0 +1,69 @@ +from pathlib import Path + +import matplotlib.pyplot as plt +from mitwindfarm import Uniform, Layout +from mitwindfarm.Plotting import plot_windfarm +from mitwindfarm.windfarm import Windfarm, CurledWindfarm +from mitwindfarm.Rotor import UnifiedAD_TI +import numpy as np +import time + +FIGDIR = Path(__file__).parent.parent / "fig" +FIGDIR.mkdir(exist_ok=True, parents=True) + + +def plot_example(): + base_windfield = Uniform(TIamb=0.05) # 5% ambient TI + wf = CurledWindfarm( + rotor_model=UnifiedAD_TI(), + base_windfield=base_windfield, + solver_kwargs=dict( + dy=1 / 10, + dz=1 / 10, + integrator="scipy_rk23", # see + k_model="k-l", # alternatives: "const", "2021" + verbose=False, + ), + ) + wf_gauss = Windfarm(TIamb=0.05) + layout = Layout([0, 5, 10], [0, 0.4, 0.8], [0, 0, 0]) + setpoints = [ + (2, np.radians(30)), + (2, np.radians(15)), + (2, 0), + ] # Example setpoints for two turbines + + wf_solutions = [] + for name, _wf in zip(["Curl", "Gauss"], [wf, wf_gauss]): + time_st = time.time() + sol = _wf(layout, setpoints) + print(f"Windfarm solution for {name} in {time.time() - time_st:.2f} seconds") + wf_solutions.append((name, sol)) + + fig, axarr = plt.subplots( + figsize=(4 * len(wf_solutions), 4), + nrows=2, + ncols=len(wf_solutions), + sharex=True, + sharey="row", + height_ratios=(1, 2), + ) + for axs, (name, sol) in zip(axarr.T, wf_solutions): + plot_windfarm(sol, ax=axs[0], pad=2, axis=True) + axs[0].set_xlabel("$x/D$") + axs[0].set_title(name) + # plot power per turbine + axs[1].bar(layout.x, [r.Cp for r in sol.rotors], width=2) + if np.all(axs == (axarr.T)[0]): # only label the first columns + axs[0].set_ylabel("$y/D$") + axs[1].set_ylabel("$C_P$") + axs[1].set_xticks(layout.x) + axs[1].set_xticklabels(np.arange(len(layout.x)) + 1) + axs[1].set_xlabel("Turbine row") + + plt.savefig(FIGDIR / f"{Path(__file__).stem}.png", bbox_inches="tight") + + +if __name__ == "__main__": + plot_example() + plt.close() diff --git a/mitwindfarm/CurledWake.py b/mitwindfarm/CurledWake.py index e07beb1..7ae7300 100644 --- a/mitwindfarm/CurledWake.py +++ b/mitwindfarm/CurledWake.py @@ -968,51 +968,5 @@ def get_heaviside(x, yax, turbines, default_x0=1): return 1 - ret -def example(): - import matplotlib.pyplot as plt - from mitwindfarm import Uniform, Layout - from mitwindfarm.Plotting import plot_windfarm - from mitwindfarm.windfarm import CurledWindfarm - from mitwindfarm.Rotor import UnifiedAD_TI - import time - - time_st = time.time() - base_windfield = Uniform(TIamb=0.05) # 5% ambient TI - wf = CurledWindfarm( - rotor_model=UnifiedAD_TI(), - base_windfield=base_windfield, - solver_kwargs=dict( - dy=1 / 10, - dz=1 / 10, - integrator="scipy_rk23", # see - k_model="k-l", # alternatives: "const", "2021" - verbose=False, - ), - ) - layout = Layout([0, 5, 10], [0, 0.4, 0.8], [0, 0, 0]) - setpoints = [ - (2, np.radians(30)), - (2, np.radians(15)), - (2, 0), - ] # Example setpoints for two turbines - sol = wf(layout, setpoints) - print(f"Windfarm solution in {time.time() - time_st:.2f} seconds") - - fig, axs = plt.subplots( - figsize=(4, 4), nrows=2, ncols=1, sharex=True, height_ratios=(1, 2) - ) - plot_windfarm(sol, ax=axs[0], pad=2, axis=True) - axs[0].set_xlabel("$x/D$") - axs[0].set_ylabel("$y/D$") - # plot power per turbine - axs[1].bar(layout.x, [r.Cp for r in sol.rotors], width=2) - axs[1].set_ylabel("$C_P$") - axs[1].set_xticks(layout.x) - axs[1].set_xticklabels(np.arange(len(layout.x)) + 1) - axs[1].set_xlabel("Turbine row") - - plt.savefig("./test_twoturbine_curl.png", bbox_inches="tight") - - if __name__ == "__main__": - example() + pass From 26c0b15fcb7e2e36cb464c4283c52471a15e2e86 Mon Sep 17 00:00:00 2001 From: Kirby Heck Date: Wed, 25 Jun 2025 16:20:58 -0500 Subject: [PATCH 5/9] Plots at hub height slice or arbitrary, user-defined z --- mitwindfarm/Plotting.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/mitwindfarm/Plotting.py b/mitwindfarm/Plotting.py index 169b7b0..b4d1ed0 100644 --- a/mitwindfarm/Plotting.py +++ b/mitwindfarm/Plotting.py @@ -4,18 +4,19 @@ from .windfarm import WindfarmSolution -def plot_windfarm(sol: WindfarmSolution, ax=None, pad=1, frame=True, axis=False, res: int=400): +def plot_windfarm(sol: WindfarmSolution, ax=None, pad=1, z=None, frame=True, axis=False, res: int=400): if ax is None: _, ax = plt.subplots() xlim = (np.min(sol.layout.x) - pad, np.max(sol.layout.x) + 10) ylim = (np.min(sol.layout.y) - pad, np.max(sol.layout.y) + pad) + z = np.mean(sol.layout.z) if z is None else z # plot windfield and turbine stats _x, _y = np.linspace(*xlim, res), np.linspace(*ylim, res) xmesh, ymesh = np.meshgrid(_x, _y) - wsp = sol.windfield.wsp(xmesh, ymesh, np.zeros_like(xmesh)) + wsp = sol.windfield.wsp(xmesh, ymesh, np.full_like(xmesh, z)) ax.imshow( wsp, extent=[*xlim, *ylim], vmin=0, vmax=2, origin="lower", cmap="RdYlBu_r" ) From c612ffbc3621314dd09159a621a9402a096db6b3 Mon Sep 17 00:00:00 2001 From: Kirby Heck Date: Wed, 25 Jun 2025 16:24:34 -0500 Subject: [PATCH 6/9] Adding a powerlaw base wind profile to curled wake example --- examples/example_08_curled_windfarm.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/examples/example_08_curled_windfarm.py b/examples/example_08_curled_windfarm.py index 381995d..e91925d 100644 --- a/examples/example_08_curled_windfarm.py +++ b/examples/example_08_curled_windfarm.py @@ -1,7 +1,7 @@ from pathlib import Path import matplotlib.pyplot as plt -from mitwindfarm import Uniform, Layout +from mitwindfarm import Uniform, Layout, PowerLaw from mitwindfarm.Plotting import plot_windfarm from mitwindfarm.windfarm import Windfarm, CurledWindfarm from mitwindfarm.Rotor import UnifiedAD_TI @@ -12,8 +12,14 @@ FIGDIR.mkdir(exist_ok=True, parents=True) -def plot_example(): - base_windfield = Uniform(TIamb=0.05) # 5% ambient TI +def plot_example(powerlaw=False): + if powerlaw: + zhub = 1 # hub height in diameters + base_windfield = PowerLaw(Uref=1, zref=zhub, exp=0.11, TIamb=0.05) + else: # plot uniform inflow + zhub = 0 + base_windfield = Uniform(TIamb=0.05) # 5% ambient TI + wf = CurledWindfarm( rotor_model=UnifiedAD_TI(), base_windfield=base_windfield, @@ -26,7 +32,7 @@ def plot_example(): ), ) wf_gauss = Windfarm(TIamb=0.05) - layout = Layout([0, 5, 10], [0, 0.4, 0.8], [0, 0, 0]) + layout = Layout([0, 5, 10], [0, 0.4, 0.8], [zhub, zhub, zhub]) setpoints = [ (2, np.radians(30)), (2, np.radians(15)), @@ -65,5 +71,5 @@ def plot_example(): if __name__ == "__main__": - plot_example() + plot_example(powerlaw=True) plt.close() From fa09bb42e622729305fd1157625d43e7cab1bc40 Mon Sep 17 00:00:00 2001 From: Kirby Date: Fri, 27 Jun 2025 18:30:52 -0400 Subject: [PATCH 7/9] Adding example comments and changing interpolation function in lmix --- examples/example_08_curled_windfarm.py | 12 +++++++----- mitwindfarm/CurledWake.py | 14 ++++++++------ 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/examples/example_08_curled_windfarm.py b/examples/example_08_curled_windfarm.py index 381995d..691e44f 100644 --- a/examples/example_08_curled_windfarm.py +++ b/examples/example_08_curled_windfarm.py @@ -20,19 +20,20 @@ def plot_example(): solver_kwargs=dict( dy=1 / 10, dz=1 / 10, - integrator="scipy_rk23", # see + integrator="scipy_rk23", # see mitwindfarm.utils.integrate k_model="k-l", # alternatives: "const", "2021" verbose=False, ), ) - wf_gauss = Windfarm(TIamb=0.05) - layout = Layout([0, 5, 10], [0, 0.4, 0.8], [0, 0, 0]) - setpoints = [ + wf_gauss = Windfarm(TIamb=0.05) # 5% ambient TI, default model is Gaussian wake + layout = Layout([0, 5, 10], [0, 0.4, 0.8], [0, 0, 0]) # non-dim by diameter D + setpoints = [ # for UnifiedAD_TI() rotor, set points are (Ctprime, yaw) tuple pairs (2, np.radians(30)), (2, np.radians(15)), (2, 0), ] # Example setpoints for two turbines + # compute windfarm solutions (Cp) wf_solutions = [] for name, _wf in zip(["Curl", "Gauss"], [wf, wf_gauss]): time_st = time.time() @@ -40,12 +41,13 @@ def plot_example(): print(f"Windfarm solution for {name} in {time.time() - time_st:.2f} seconds") wf_solutions.append((name, sol)) + # plot the comparison: wind speed and power fig, axarr = plt.subplots( figsize=(4 * len(wf_solutions), 4), nrows=2, ncols=len(wf_solutions), sharex=True, - sharey="row", + sharey="row", height_ratios=(1, 2), ) for axs, (name, sol) in zip(axarr.T, wf_solutions): diff --git a/mitwindfarm/CurledWake.py b/mitwindfarm/CurledWake.py index 7ae7300..8208992 100644 --- a/mitwindfarm/CurledWake.py +++ b/mitwindfarm/CurledWake.py @@ -14,7 +14,7 @@ from numpy.typing import ArrayLike import numpy as np from scipy.signal import convolve2d -from scipy.interpolate import interpn, interp1d +from scipy.interpolate import interpn, make_interp_spline from mitwindfarm.Windfield import Windfield from mitwindfarm.Rotor import RotorSolution @@ -904,13 +904,17 @@ def get_wake_bounds_z(du, thresh=0.05, relative=True): return zcross -def interpolate_lmix(du, y, method="nearest", fill_value=1.0, max_value=None, pad=True): +def interpolate_lmix(du, y, k=0, fill_value=1.0, max_value=None, pad=True): """ Interpolates the mixing length scale from the du field. Parameters: - du: 2D array of delta_u - y: y-coordinates + - k: interpolation order (default: 0, nearest neighbor) + - fill_value: value to fill if no bounds are found (default: 1.0) + - max_value: maximum value for the mixing length scale (default: None, no limit) + - pad: whether to pad the du field with zeros (default: True) Returns: - lmix: 1D array of mixing length scale @@ -932,12 +936,10 @@ def interpolate_lmix(du, y, method="nearest", fill_value=1.0, max_value=None, pa y_mean = np.mean(y_bounds, axis=0) y_width = np.diff(y_bounds, axis=0).flatten() - f = interp1d( + f = make_interp_spline( y_mean, y_width, - kind=method, - fill_value=(y_width[0], y_width[-1]), - bounds_error=False, + k=k, # nearest interpolation ) if max_value is None: return f(y) From 909253bce3d71f1a04e45cfc07267e1c0b4235b6 Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Wed, 15 Oct 2025 17:04:02 -0400 Subject: [PATCH 8/9] Fix rotor solution indexing --- mitwindfarm/Rotor.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/mitwindfarm/Rotor.py b/mitwindfarm/Rotor.py index 7596093..43fd7b7 100644 --- a/mitwindfarm/Rotor.py +++ b/mitwindfarm/Rotor.py @@ -268,12 +268,12 @@ def __call__( # rotor solution is normalised by REWS. Convert normalisation to U_inf and return return RotorSolution( yaw, - sol.Cp[0] * REWS**3, - sol.Ct[0] * REWS**2, + sol.Cp * REWS**3, + sol.Ct * REWS**2, sol.Ctprime, - sol.an[0] * REWS, - sol.u4[0] * REWS, - sol.v4[0] * REWS, + sol.an * REWS, + sol.u4 * REWS, + sol.v4 * REWS, REWS, TI=RETI, extra=sol, From e97b75dd807963b2194c627075b67886426a4f0b Mon Sep 17 00:00:00 2001 From: Skylar A Gering Date: Thu, 30 Oct 2025 00:38:13 -0400 Subject: [PATCH 9/9] Sg/kl model dev (#31) * Finalize first try at implementation with tilt * Example runs with zero tilt * Debug plotting with tilt * Finish testing curled wake model * Update dependencies * Add back in factor of D * Add tests for rotor differences * Changed tests * Finish tests and put back in kirby rotor code * Update gaussian smoothing to account for tilt * Update UMM compatibility * Update UMM and MITRotor packages * Update package version * Sg/tilted bem dev (#32) * Update BEM rotor to allow for tilt input * Update plotting to allow any slice * Add new yaw and tilt example * Debugging new tilt example * Finish debugging MITWindFarm yaw/tilt * Add in optimization timing * Add in timing * Rename example file * Example cleanup for PR * New example with yaw and tilt comparisons added * Clean up pre-merge * Final example cleanup * Finalize examples * Clean up unneeded calls to super --- examples/MITWindfarm_quickstart.ipynb | 87 +- examples/example_05_basic_windfarm.py | 9 +- examples/example_07_BEM_yaw_optimisation.py | 39 +- examples/example_08_curled_windfarm.py | 68 +- examples/example_09_BEM_tilt_optimization.py | 68 + examples/example_10_BEM_yaw_tilt.py | 73 + mitwindfarm/CurledWake.py | 66 +- mitwindfarm/Plotting.py | 77 +- mitwindfarm/Rotor.py | 65 +- poetry.lock | 2694 ++++++++++++------ pyproject.toml | 2 +- tests/test_curled_wake.py | 115 + tests/test_wake.py | 5 +- 13 files changed, 2310 insertions(+), 1058 deletions(-) create mode 100644 examples/example_09_BEM_tilt_optimization.py create mode 100644 examples/example_10_BEM_yaw_tilt.py create mode 100644 tests/test_curled_wake.py diff --git a/examples/MITWindfarm_quickstart.ipynb b/examples/MITWindfarm_quickstart.ipynb index 43243ab..f817697 100644 --- a/examples/MITWindfarm_quickstart.ipynb +++ b/examples/MITWindfarm_quickstart.ipynb @@ -20,13 +20,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ "from mitwindfarm import Area, AD, UnifiedAD, BEM, GaussianWakeModel, VariableKwGaussianWakeModel\n", "from mitwindfarm import Uniform, PowerLaw, Niayifar, Layout, GridLayout, Windfarm, Plotting\n", - "from MITRotor.ReferenceTurbines import IEA15MW" + "from MITRotor.ReferenceTurbines import IEA15MW\n", + "from MITRotor.Momentum import UnifiedMomentum" ] }, { @@ -38,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 58, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +58,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A `WindFarm` object has 5 optional parameters, each of which help determine its function. These parameters are the: `rotor_model`, `wake_model`, `superposition`, `base_windfield`, and `TIamb`. The first 4 arguments are objects/models. Their instantiation is discussed below. `TIamb` is the ambient turbulence intensity, which is simply a float value." + "A `WindFarm` object has 5 optional parameters, each of which help determine its function. These parameters are the: `rotor_model`, `wake_model`, `superposition`, `base_windfield`, and `TIamb`. The first 4 arguments are objects/models. Their instantiation is discussed below. `TIamb` is the ambient turbulence intensity, which is simply a float value.\n", + "\n", + "Beyond the standard windfarm, there is also a `CurledWindfarm` that implements the curled wake model. See `example_08_curled_windfarm.py` to see how to use that. It follows many similar principles to the rest of this guide." ] }, { @@ -71,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 59, "metadata": {}, "outputs": [], "source": [ @@ -108,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ @@ -129,11 +132,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ - "rotor_bem = BEM(IEA15MW())" + "rotor_bem = BEM(IEA15MW(), momentum_model = UnifiedMomentum())" ] }, { @@ -144,23 +147,23 @@ "\n", "Analogously to how we are currently building a `WindFarm` object so that we can solve for a `WindFarmSolution`, a `Rotor` has a `RotorSolution`. So, if you are only interested in a single rotor solution, you can now solve for that rotor's solution, rather than building an entire wind farm, which will solve for all of the rotor's solutions together in tandem.\n", "\n", - "For the `AD` and `UniformAD` models, you need to provide a `x`, `y`, and `z` arguments that specify the location you want the solution for, measured in distance from the centroid of the rotor. You also need to provide `windfield` model, as well as `Ctprime` and `yaw` values. We will later refer to `Ctprime` and `yaw` as \"setpoints\".\n", + "For the `AD` and `UniformAD` models, you need to provide a `x`, `y`, and `z` arguments that specify the location you want the solution for, measured in distance from the centroid of the rotor. You also need to provide `windfield` model, as well as `Ctprime`, `yaw`, and `tilt` values. We will later refer to `Ctprime`, `yaw`, and `tilt` as \"setpoints\".\n", "\n", - "Similarly, for the `BEM` model, you also need to provide `x`, `y`, `z`, and `windfield` arguments. The `BEM` setpoints, however are different: `pitch`, `tsr` (tip speed ratio), and `yaw`." + "Similarly, for the `BEM` model, you also need to provide `x`, `y`, `z`, and `windfield` arguments. The `BEM` setpoints, however are different: `pitch`, `tsr` (tip speed ratio), `yaw`, and `tilt`. Note that within `MITRotor`, there are a few specifications on which setups support tilt. See the `MITRotor` quickstart guide for that information." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Control setpoints: Ctprime = 2.00, yaw = 0.17\n", + "Control setpoints: Ctprime = 2.00, yaw = 0.17, tilt = 0.09\n", "Power coefficient: 0.58\n", - "Thrust coefficient: 0.88\n", + "Thrust coefficient: 0.87\n", "Axial induction: 0.33\n", "Far-wake streamwise velocity: 0.35\n", "Far-wake lateral velocity: -0.04\n", @@ -170,9 +173,9 @@ } ], "source": [ - "ad_solution = rotor_ad(x = 0, y = 0, z = 0, windfield = uniform_wind_field, Ctprime = 2, yaw = np.deg2rad(10))\n", + "ad_solution = rotor_ad(x = 0, y = 0, z = 0, windfield = uniform_wind_field, Ctprime = 2, yaw = np.deg2rad(10), tilt = np.deg2rad(5))\n", "\n", - "print(f\"Control setpoints: Ctprime = {ad_solution.Ctprime:2.2f}, yaw = {ad_solution.yaw:2.2f}\")\n", + "print(f\"Control setpoints: Ctprime = {ad_solution.Ctprime:2.2f}, yaw = {ad_solution.yaw:2.2f}, tilt = {ad_solution.tilt:2.2f}\")\n", "print(f\"Power coefficient: {ad_solution.Cp:2.2f}\")\n", "print(f\"Thrust coefficient: {ad_solution.Ct:2.2f}\")\n", "print(f\"Axial induction: {ad_solution.an:2.2f}\")\n", @@ -184,29 +187,29 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Control setpoints: Ctprime = 1.61, yaw = 0.17\n", - "Power coefficient: 0.49\n", - "Thrust coefficient: 0.78\n", - "Local thrust coefficient: 1.61\n", - "Axial induction: 0.27\n", - "Far-wake streamwise velocity: 0.44\n", - "Far-wake lateral velocity: -0.04\n", + "Control setpoints: Ctprime = 1.80, yaw = 0.17, tilt = 0.09\n", + "Power coefficient: 0.42\n", + "Thrust coefficient: 0.73\n", + "Local thrust coefficient: 1.80\n", + "Axial induction: 0.35\n", + "Far-wake streamwise velocity: 0.54\n", + "Far-wake lateral velocity: -0.03\n", "Rotor-effective wind speed: 1.00\n", "Wake turbulence intensity: 0.00\n" ] } ], "source": [ - "bem_solution = rotor_bem(x = 0, y = 0, z = 0, windfield = uniform_wind_field, pitch = 0, tsr = 9, yaw = np.deg2rad(10))\n", + "bem_solution = rotor_bem(x = 0, y = 0, z = 0, windfield = uniform_wind_field, pitch = 0, tsr = 9, yaw = np.deg2rad(10), tilt = np.deg2rad(5))\n", "\n", - "print(f\"Control setpoints: Ctprime = {bem_solution.Ctprime:2.2f}, yaw = {ad_solution.yaw:2.2f}\")\n", + "print(f\"Control setpoints: Ctprime = {bem_solution.Ctprime:2.2f}, yaw = {bem_solution.yaw:2.2f}, tilt = {bem_solution.tilt:2.2f}\")\n", "print(f\"Power coefficient: {bem_solution.Cp:2.2f}\")\n", "print(f\"Thrust coefficient: {bem_solution.Ct:2.2f}\")\n", "print(f\"Local thrust coefficient: {bem_solution.Ctprime:2.2f}\")\n", @@ -223,7 +226,7 @@ "source": [ "### Wake Model\n", "\n", - "Within the package, there is a `WakeModel` abstract class with two concrete types: the `GaussianWakeModel` and the `VariableKwGaussianWakeModel`. \n", + "Within the package, there is a `WakeModel` abstract class with two concrete types: the `GaussianWakeModel` and the `VariableKwGaussianWakeModel`. Note that the curled wake model is also implemented, but requires a different type of wind farm, a `CurledWindfarm`, due to different solving methods. See `example_08_curled_windfarm.py` for more information.\n", "\n", "The `GaussianWakeModel` has the following optional arguments (and default values): `sigma` (0.25), `kw` (0.07), `WATI_sigma_multiplier` (1.0), and `xmax` (100.0).\n", "\n", @@ -235,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 64, "metadata": {}, "outputs": [], "source": [ @@ -261,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ @@ -286,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 66, "metadata": {}, "outputs": [], "source": [ @@ -320,7 +323,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -334,7 +337,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 68, "metadata": {}, "outputs": [ { @@ -374,12 +377,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 69, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -395,12 +398,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 70, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -420,16 +423,16 @@ "source": [ "### Wind Farm `setpoints`\n", "\n", - "Setpoints are properties specific to the rotor model. For both the `AD` and `UnifiedAD` models, the `setpoints` are `Ctprime`, `yaw`, and `tilt`. For `BEM`, the `setpoints` are `pitch`, `tsr`, and `yaw` (`tilt` is not yet implemnted for BEM). A tuple of setpoints must be provided for each turbine in a wind farm, in the form of a vector of tuples." + "Setpoints are properties specific to the rotor model. For both the `AD` and `UnifiedAD` models, the `setpoints` are `Ctprime`, `yaw`, and `tilt`. For `BEM`, the `setpoints` are `pitch`, `tsr`, and `yaw`, and `tilt`. A tuple of setpoints must be provided for each turbine in a wind farm, in the form of a vector of tuples." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 71, "metadata": {}, "outputs": [], "source": [ - "bem_setpoints = [(0, 7, 0) for i in range(len(stag_grid_layout))]" + "bem_setpoints = [(0, 7, 0, 0) for i in range(len(stag_grid_layout))]" ] }, { @@ -448,12 +451,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 72, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -479,7 +482,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "mitwindfarm-iuGKr_rh-py3.12", "language": "python", "name": "python3" }, @@ -493,7 +496,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.6" + "version": "3.12.11" } }, "nbformat": 4, diff --git a/examples/example_05_basic_windfarm.py b/examples/example_05_basic_windfarm.py index 75a8488..d1a77bc 100644 --- a/examples/example_05_basic_windfarm.py +++ b/examples/example_05_basic_windfarm.py @@ -1,4 +1,5 @@ from pathlib import Path +import numpy as np import matplotlib.pyplot as plt from MITRotor import IEA15MW @@ -12,10 +13,10 @@ if __name__ == "__main__": windfarm = Windfarm(rotor_model=BEM(IEA15MW())) - setpoints = [ - (0, 7, 0), - (0, 7, 0), - (0, 7, 0), + setpoints = [ # pitch, tsr, yaw, tilt + (0, 7, 0, 0), + (0, 7, 0, 0), + (0, 7, 0, 0), ] layout = Layout([0, 12 / 2, 24 / 2], [0, 0, 0]) diff --git a/examples/example_07_BEM_yaw_optimisation.py b/examples/example_07_BEM_yaw_optimisation.py index b7e190d..e0a6451 100644 --- a/examples/example_07_BEM_yaw_optimisation.py +++ b/examples/example_07_BEM_yaw_optimisation.py @@ -6,6 +6,7 @@ from mitwindfarm import Plotting from mitwindfarm.windfarm import Windfarm, WindfarmSolution, Layout from mitwindfarm.Rotor import BEM +from MITRotor.Momentum import UnifiedMomentum from MITRotor.ReferenceTurbines import IEA15MW from rich import print import numpy as np @@ -13,36 +14,31 @@ FIGDIR = Path(__file__).parent.parent / "fig" FIGDIR.mkdir(exist_ok=True, parents=True) -windfarm = Windfarm(rotor_model=BEM(IEA15MW()), TIamb=0.1) -layout = Layout([0, 12, 24], [0.0, 0.5, 1.0]) - +momentum_model= UnifiedMomentum(averaging = "rotor") +windfarm = Windfarm( + rotor_model=BEM(IEA15MW(), momentum_model = momentum_model), + TIamb=0.1, +) +layout = Layout([0, 12, 24], [0.0, 0.5, 1.0], [0.0, 0.0, 0.0]) def solve_for_setpoints(x) -> WindfarmSolution: - setpoints = [(x[0], x[1], x[2]), (x[3], x[4], x[5]), (x[6], x[7], x[8])] + setpoints = [(x[0], x[1], x[2], 0.0), (x[3], x[4], x[5], 0.0), (x[6], x[7], x[8], 0.0)] return windfarm(layout, setpoints) - def objective_func(x): windfarm_sol = solve_for_setpoints(x) return -windfarm_sol.Cp - if __name__ == "__main__": - x0 = [0, 7, 0, 0, 7, 0, 0, 7, 0] + nturbs = 3 + angle_bounds = (-np.deg2rad(15), np.deg2rad(15)) + tsr_bounds = (3, 10) + x0 = [0, 7, 0] * nturbs + sol = minimize( objective_func, x0, - bounds=[ - (-np.deg2rad(15), np.deg2rad(15)), - (3, 10), - (-np.deg2rad(15), np.deg2rad(15)), - (-np.deg2rad(15), np.deg2rad(15)), - (3, 10), - (-np.deg2rad(15), np.deg2rad(15)), - (-np.deg2rad(15), np.deg2rad(15)), - (3, 10), - (-np.deg2rad(15), np.deg2rad(15)), - ], + bounds=[angle_bounds,tsr_bounds,angle_bounds] * nturbs, ) print(sol) @@ -53,12 +49,17 @@ def objective_func(x): fig, axes = plt.subplots(2, 1) Plotting.plot_windfarm(windfarm_sol_ref, axes[0]) Plotting.plot_windfarm(windfarm_sol_opt, axes[1]) + fig.suptitle("Original and Optimized Wind Farm Layout for Yaw ($z = 0$)") + axes[0].set_xlabel("$x/D$") + axes[1].set_xlabel("$x/D$") + axes[0].set_ylabel("$y/D$") + axes[1].set_ylabel("$y/D$") axes[0].set_title(f"$C_P$: {windfarm_sol_ref.Cp:2.3f}") axes[1].set_title( f"$C_P$: {windfarm_sol_opt.Cp:2.3f} ({100*(windfarm_sol_opt.Cp/windfarm_sol_ref.Cp - 1):+2.1f}%)" ) - + plt.tight_layout() plt.savefig( FIGDIR / "example_07_BEM_yaw_optimisation.png", dpi=300, bbox_inches="tight" ) diff --git a/examples/example_08_curled_windfarm.py b/examples/example_08_curled_windfarm.py index 11fa243..efb4710 100644 --- a/examples/example_08_curled_windfarm.py +++ b/examples/example_08_curled_windfarm.py @@ -20,7 +20,7 @@ def plot_example(powerlaw=False): zhub = 0 base_windfield = Uniform(TIamb=0.05) # 5% ambient TI - wf = CurledWindfarm( + wf_curled = CurledWindfarm( rotor_model=UnifiedAD_TI(), base_windfield=base_windfield, solver_kwargs=dict( @@ -33,45 +33,67 @@ def plot_example(powerlaw=False): ) wf_gauss = Windfarm(TIamb=0.05) # 5% ambient TI, default model is Gaussian wake layout = Layout([0, 5, 10], [0, 0.4, 0.8], [zhub, zhub, zhub]) # non-dim by diameter D - setpoints = [ # for UnifiedAD_TI() rotor, set points are (Ctprime, yaw) tuple pairs - (2, np.radians(30)), - (2, np.radians(15)), - (2, 0), - ] # Example setpoints for two turbines + setpoints = [ # for UnifiedAD_TI() rotor, set points are (Ctprime, yaw, tilt) tuple pairs + (2, np.radians(30), np.radians(20)), + (2, np.radians(15), np.radians(10)), + (2, 0, 0), + ] # Example setpoints for three turbines # compute windfarm solutions (Cp) wf_solutions = [] - for name, _wf in zip(["Curl", "Gauss"], [wf, wf_gauss]): + for name, _wf in zip(["Curl", "Gauss"], [wf_curled, wf_gauss]): time_st = time.time() sol = _wf(layout, setpoints) print(f"Windfarm solution for {name} in {time.time() - time_st:.2f} seconds") wf_solutions.append((name, sol)) - # plot the comparison: wind speed and power - fig, axarr = plt.subplots( - figsize=(4 * len(wf_solutions), 4), - nrows=2, + # plot the comparison: wind speed (streamwise slice) and power + fig1, axarr1 = plt.subplots( + figsize=(4 * len(wf_solutions), 6), + nrows=3, ncols=len(wf_solutions), sharex=True, sharey="row", - height_ratios=(1, 2), + height_ratios=(1, 1, 2), ) - for axs, (name, sol) in zip(axarr.T, wf_solutions): - plot_windfarm(sol, ax=axs[0], pad=2, axis=True) + for axs, (name, sol) in zip(axarr1.T, wf_solutions): + plot_windfarm(sol, ax=axs[0], z = zhub, pad=2, axis=True) + y_plot_val = 0 + plot_windfarm(sol, ax=axs[1], y = y_plot_val, pad=2, axis=True) axs[0].set_xlabel("$x/D$") - axs[0].set_title(name) + axs[1].set_xlabel("$x/D$") + axs[0].set_title(name + f" at z = {zhub}") + axs[1].set_title(name + f" at y = {y_plot_val}") # plot power per turbine - axs[1].bar(layout.x, [r.Cp for r in sol.rotors], width=2) - if np.all(axs == (axarr.T)[0]): # only label the first columns + axs[2].bar(layout.x, [r.Cp for r in sol.rotors], width=2) + if np.all(axs == (axarr1.T)[0]): # only label the first columns axs[0].set_ylabel("$y/D$") - axs[1].set_ylabel("$C_P$") - axs[1].set_xticks(layout.x) - axs[1].set_xticklabels(np.arange(len(layout.x)) + 1) - axs[1].set_xlabel("Turbine row") + axs[1].set_ylabel("$z/D$") + axs[2].set_ylabel("$C_P$") + axs[2].set_xticks(layout.x) + axs[2].set_xticklabels(np.arange(len(layout.x)) + 1) + axs[2].set_xlabel("Turbine row") + + plt.savefig(FIGDIR / f"{Path(__file__).stem}1.png", bbox_inches="tight") - plt.savefig(FIGDIR / f"{Path(__file__).stem}.png", bbox_inches="tight") + fig2, axarr2 = plt.subplots( + figsize=(4 * len(wf_solutions), 4), + nrows=1, + ncols=len(wf_solutions), + sharex=True, + sharey="row", + ) + for axs, (name, sol) in zip(axarr2.T, wf_solutions): + # at first turbine's hub + x_plot_val = 4 + plot_windfarm(sol, ax=axs, x = x_plot_val, pad=2, axis=True) + axs.set_title(name + f" at x = {x_plot_val}") + axs.set_xlabel("$y/D$") + axs.set_ylabel("$z/D$") + + plt.savefig(FIGDIR / f"{Path(__file__).stem}2.png", bbox_inches="tight") if __name__ == "__main__": - plot_example(powerlaw=True) + plot_example(powerlaw=False) plt.close() diff --git a/examples/example_09_BEM_tilt_optimization.py b/examples/example_09_BEM_tilt_optimization.py new file mode 100644 index 0000000..e513b53 --- /dev/null +++ b/examples/example_09_BEM_tilt_optimization.py @@ -0,0 +1,68 @@ +from pathlib import Path + +import matplotlib.pyplot as plt +from scipy.optimize import minimize + +from mitwindfarm import Plotting +from mitwindfarm.windfarm import Windfarm, WindfarmSolution, Layout +from mitwindfarm.Rotor import BEM +from MITRotor.ReferenceTurbines import IEA15MW +from MITRotor.Momentum import UnifiedMomentum +from rich import print +import numpy as np + +FIGDIR = Path(__file__).parent.parent / "fig" +FIGDIR.mkdir(exist_ok=True, parents=True) + +# Note that this setup is meant to mimic the example 7 yaw optimization setup. +# Thus we are optimizing pitch, tsr, and tilt. +# It becomes visually apparent that optimizing for yaw vs tilt return the same thing! +momentum_model= UnifiedMomentum(averaging = "rotor") +windfarm = Windfarm( + rotor_model=BEM(IEA15MW(), momentum_model = momentum_model), + TIamb=0.1, +) +layout = Layout([0, 12, 24], [0.0, 0.0, 0.0], [2.0, 1.5, 1.0]) + +def solve_for_setpoints(x) -> WindfarmSolution: + setpoints = [(x[0], x[1], 0.0, x[2]), (x[3], x[4], 0.0, x[5]), (x[6], x[7], 0.0, x[8])] + return windfarm(layout, setpoints) + +def objective_func(x): + windfarm_sol = solve_for_setpoints(x) + return -windfarm_sol.Cp + +if __name__ == "__main__": + nturbs = 3 + # note that we limit to positive tilt so the blades don't hit to shaft + half_angle_bounds = (0, np.deg2rad(15)) + tsr_bounds = (3, 10) + x0 = [0, 7, 0] * nturbs + + sol = minimize( + objective_func, + x0, + bounds=[half_angle_bounds,tsr_bounds,half_angle_bounds] * nturbs, + ) + print(sol) + + windfarm_sol_ref = solve_for_setpoints(x0) + windfarm_sol_opt = solve_for_setpoints(sol.x) + print(windfarm_sol_opt) + + fig, axes = plt.subplots(2, 1) + Plotting.plot_windfarm(windfarm_sol_ref, axes[0], y = 0) + Plotting.plot_windfarm(windfarm_sol_opt, axes[1], y = 0) + fig.suptitle("Original and Optimized Wind Farm Layout for Tilt ($y = 0$)") + axes[0].set_xlabel("$x/D$") + axes[1].set_xlabel("$x/D$") + axes[0].set_ylabel("$y/D$") + axes[1].set_ylabel("$y/D$") + axes[0].set_title(f"$C_P$: {windfarm_sol_ref.Cp:2.3f}") + axes[1].set_title( + f"$C_P$: {windfarm_sol_opt.Cp:2.3f} ({100*(windfarm_sol_opt.Cp/windfarm_sol_ref.Cp - 1):+2.1f}%)" + ) + + plt.savefig( + FIGDIR / "example_09_BEM_tilt_optimisation.png", dpi=300, bbox_inches="tight" + ) diff --git a/examples/example_10_BEM_yaw_tilt.py b/examples/example_10_BEM_yaw_tilt.py new file mode 100644 index 0000000..8b51a66 --- /dev/null +++ b/examples/example_10_BEM_yaw_tilt.py @@ -0,0 +1,73 @@ +from pathlib import Path + +import matplotlib.pyplot as plt +from scipy.optimize import minimize + +from mitwindfarm import Plotting +from mitwindfarm.windfarm import Windfarm, WindfarmSolution, Layout +from mitwindfarm.Rotor import BEM +from MITRotor.Momentum import UnifiedMomentum +from MITRotor.ReferenceTurbines import IEA15MW +from UnifiedMomentumModel.Utilities.Geometry import calc_eff_yaw +from rich import print +import numpy as np + +FIGDIR = Path(__file__).parent.parent / "fig" +FIGDIR.mkdir(exist_ok=True, parents=True) + +momentum_model= UnifiedMomentum(averaging = "rotor") +windfarm = Windfarm( + rotor_model=BEM(IEA15MW(), momentum_model = momentum_model), + TIamb=0.1, +) +layout = Layout([0, 12], [0.0, 0.0], [0.0, 0.0]) + +def solve_for_setpoints(x) -> WindfarmSolution: + setpoints = [(x[0], x[1], x[2], 0.0), (x[3], x[4], x[5], 0.0), (x[6], x[7], x[8], 0.0)] + return windfarm(layout, setpoints) + +def objective_func(x): + windfarm_sol = solve_for_setpoints(x) + return -windfarm_sol.Cp + +if __name__ == "__main__": + pitch_val = 0 + tsr_val = 7 + + yaw_tilt_val = np.deg2rad(15) + eff_yaw = calc_eff_yaw(yaw_tilt_val, yaw_tilt_val) + yaw_val = eff_yaw + tilt_val = eff_yaw + + aligned_setpoints = (pitch_val, tsr_val, 0, 0) + setpoints_yaw = [(pitch_val, tsr_val, eff_yaw, 0), aligned_setpoints] + setpoints_tilt = [(pitch_val, tsr_val, 0, eff_yaw), aligned_setpoints] + setpoints_yaw_and_tilt = [(pitch_val, tsr_val, yaw_tilt_val, yaw_tilt_val), aligned_setpoints] + + yaw_sol = windfarm(layout, setpoints_yaw) + tilt_sol = windfarm(layout, setpoints_tilt) + yaw_and_tilt_sol = windfarm(layout, setpoints_yaw_and_tilt) + + fig, axes = plt.subplots(2, 3) + Plotting.plot_windfarm(yaw_sol, axes[0, 0], z = 0) + Plotting.plot_windfarm(tilt_sol, axes[0, 1], z = 0) + Plotting.plot_windfarm(yaw_and_tilt_sol, axes[0, 2], z = 0) + axes[0, 0].set_ylabel("$z/D$") + + Plotting.plot_windfarm(yaw_sol, axes[1, 0], y = 0) + Plotting.plot_windfarm(tilt_sol, axes[1, 1], y = 0) + Plotting.plot_windfarm(yaw_and_tilt_sol, axes[1, 2], y = 0) + axes[1, 0].set_ylabel("$y/D$") + axes[1, 0].set_xlabel("$x/D$") + axes[1, 1].set_xlabel("$x/D$") + axes[1, 2].set_xlabel("$x/D$") + + fig.suptitle("$C_P$ for Equivalent Turbine Setups", size = 16) + deg_yaw_tilt, deg_eff_yaw = np.rad2deg(yaw_tilt_val), np.rad2deg(eff_yaw) + axes[0, 0].set_title(f"Yaw {np.round(deg_eff_yaw, decimals=1)}$^\circ$\n$C_P$: {yaw_sol.Cp:2.3f}") + axes[0, 1].set_title(f"Tilt {np.round(deg_eff_yaw, decimals=1)}$^\circ$\n$C_P$: {tilt_sol.Cp:2.3f}") + axes[0, 2].set_title(f"Yaw {np.round(deg_yaw_tilt, decimals=1)}$^\circ$ & Tilt {np.round(deg_yaw_tilt, decimals=1)}$^\circ$\n$C_P$: {yaw_and_tilt_sol.Cp:2.3f}") + plt.tight_layout() + plt.savefig( + FIGDIR / "example_10_yaw_tilt_comparison.png", dpi=300, bbox_inches="tight" + ) diff --git a/mitwindfarm/CurledWake.py b/mitwindfarm/CurledWake.py index 8208992..dd82458 100644 --- a/mitwindfarm/CurledWake.py +++ b/mitwindfarm/CurledWake.py @@ -23,6 +23,7 @@ IntegrationException, DomainExpansionRequest, ) +from UnifiedMomentumModel.Utilities.Geometry import calc_eff_yaw, eff_yaw_rotation, eff_yaw_inv_rotation from mitwindfarm.utils.differentiate import second_der @@ -218,47 +219,42 @@ def stamp_ic( if self.use_r4 else D / 2 ) - ay = r4 * np.cos(rotor.yaw) - az = r4 # TODO: could factor in rotor tilt later on + # calculate yaw angle in "yaw-only" frame + eff_yaw = calc_eff_yaw(rotor.yaw, rotor.tilt) + # create stencil shape = ic_stencil( self.grid[1], self.grid[2], yt, zt, smooth_fact=smooth_fact, - ay=ay, - az=az, + r4 = r4, + eff_yaw = eff_yaw, + yaw = rotor.yaw, + tilt = rotor.tilt, ) - if self.ic_method == "fx": - # NOTE: DO NOT USE - thrust = -rotor.Ct * 0.5 * np.pi / 4 - self.extra_fx += ( - shape * thrust / (np.sum(shape) * self.dy * self.dz * self.dx) - ) - warn( - "`fx` is not a reliable method for stamping initial conditions. Use `du` instead." - ) - else: - # stamp the rotor solution into the wind field - # TODO: check du is negative? - delta_u = rotor.u4 - rotor.REWS # delta_u, adjusted by REWS - self.du[-1, ...] += shape * delta_u + # stamp the rotor solution into the wind field + # TODO: check du is negative? + delta_u = rotor.u4 - rotor.REWS # delta_u, adjusted by REWS + self.du[-1, ...] += shape * delta_u # dv, dw initial conditions: - if rotor.yaw == 0: + if (rotor.yaw == 0) and (rotor.tilt == 0): return # no additional dv, dw to stamp in for this turbine # TODO: Put this in a separate module - # self.N_vortex = 10 # make this a parameter - # self.vortex_sigma = 0.2 # sigma/D, for de-singularization # r-axis: clip edges to prevent singularities - r_i = np.linspace(-(D - self.dz) / 2, (D - self.dz) / 2, self.N_vortex) - # NOTE: rotor.Ct differs from Shapiro et al. (2018) definition - includes cos^2(yaw) - Gamma_0 = 0.5 * D * rotor.REWS * rotor.Ct * np.sin(rotor.yaw) + d_yx = np.maximum(self.dy, self.dz) + # along z-axis in yaw-only frame (also the radial distance of each point from center in any frame) + r_i = np.linspace(-(D - d_yx) / 2, (D - d_yx) / 2, self.N_vortex) + # rotate points into yaw-and-tilt frame + _, y_i, z_i = eff_yaw_inv_rotation(np.zeros_like(r_i), np.zeros_like(r_i), r_i, eff_yaw, rotor.yaw, rotor.tilt) + # NOTE: rotor.Ct differs from Shapiro et al. (2018) definition - includes cos^2(eff_yaw) + Gamma_0 = 0.5 * D * rotor.REWS * rotor.Ct * np.sin(eff_yaw) Gamma_i = ( - Gamma_0 * 4 * r_i / (self.N_vortex * D**2 * np.sqrt(1 - (2 * r_i / D) ** 2)) + Gamma_0 * 4 * r_i / (self.N_vortex * D * np.sqrt(1 - (2 * r_i / D) ** 2)) ) # generally, vortices can decay, so sigma should be a function of x # TODO @@ -268,7 +264,8 @@ def stamp_ic( yG, zG = np.meshgrid(self.grid[1], self.grid[2], indexing="ij") yG = yG[..., None] zG = zG[..., None] - rsq = (yG - yt) ** 2 + (zG - zt - r_i[None, None, :]) ** 2 # 3D grid variable + + rsq = (yG - yt - y_i[None, None, :]) ** 2 + (zG - zt - z_i[None, None, :]) ** 2 # 3D grid variable rsq = np.clip(rsq, 1e-8, None) # avoid singularities # put pieces together: @@ -276,8 +273,8 @@ def stamp_ic( summation = exponent / (2 * np.pi * rsq) * Gamma_i[None, None, :] # sum all vortices along last dim - v = np.sum(summation * (zG - zt - r_i[None, None, :]), axis=-1) - w = np.sum(summation * -(yG - yt), axis=-1) + v = np.sum(summation * (zG - zt - z_i[None, None, :]), axis=-1) + w = np.sum(summation * -(yG - yt - y_i[None, None, :]), axis=-1) self.dv[-1, ...] += v # stamp in dv self.dw[-1, ...] += w # stamp in dw @@ -825,7 +822,7 @@ def check_state_bounds(state, thresh=1e-4): return expand_y, expand_z -def ic_stencil(y, z, yt, zt, smooth_fact=1, ay=0.5, az=None) -> np.ndarray: +def ic_stencil(y, z, yt, zt, smooth_fact=1, r4 = 0.5, eff_yaw = 0.0, yaw = 0.0, tilt = 0.0) -> np.ndarray: """ Stencil for turbine initial condition. This is a 2D Gaussian kernel that is convolved with an indicator function. @@ -837,21 +834,22 @@ def ic_stencil(y, z, yt, zt, smooth_fact=1, ay=0.5, az=None) -> np.ndarray: - ay: Width of the stencil in the y-direction (default: 0.5). - az: Width of the stencil in the z-direction (default: ay). """ - az = ay if az is None else az - yG, zG = np.meshgrid(y, z, indexing="ij") dy = y[1] - y[0] dz = z[1] - z[0] # assume these are equally spaced axes kernel_y = np.arange(-10, 11)[:, None] * dy kernel_z = np.arange(-10, 11)[None, :] * dz - # turb = ((yG - yt) ** 2 + (zG - zt) ** 2) < R**2 - turb = (((yG - yt) / ay) ** 2 + ((zG - zt) / az) ** 2) < 1.0 + # determine if points are in the turbine when rotated into the "yaw-only" frame + ay, az = r4 * np.cos(eff_yaw), r4 + _, yvals, z_vals = eff_yaw_rotation(np.ones_like(yG), yG - yt, zG - zt, eff_yaw, yaw, tilt) + turb = ((yvals / ay) ** 2 + (z_vals / az) ** 2) < 1.0 + # create gaussian in the ground frame gauss = np.exp( -(kernel_y**2 + kernel_z**2) / (np.sqrt(dy * dz) * smooth_fact) ** 2 / 2 ) gauss /= np.sum(gauss) # make sure this is normalized to 1 - return convolve2d(turb, gauss, "same") + return convolve2d(turb, gauss, "same") # smooth edges of gaussian def get_wake_bounds_y(du, thresh=0.05, relative=True): diff --git a/mitwindfarm/Plotting.py b/mitwindfarm/Plotting.py index b4d1ed0..21150cb 100644 --- a/mitwindfarm/Plotting.py +++ b/mitwindfarm/Plotting.py @@ -4,37 +4,62 @@ from .windfarm import WindfarmSolution -def plot_windfarm(sol: WindfarmSolution, ax=None, pad=1, z=None, frame=True, axis=False, res: int=400): +def plot_windfarm(sol: WindfarmSolution, ax=None, pad=1, x=None, y=None, z=None, frame=True, axis=False, res: int=400): + if sum(val is not None for val in (x, y, z)) > 1: + raise ValueError("At most one of x, y, or z can br provided to plot a 2D slice of the wind farm") + if ax is None: _, ax = plt.subplots() - xlim = (np.min(sol.layout.x) - pad, np.max(sol.layout.x) + 10) ylim = (np.min(sol.layout.y) - pad, np.max(sol.layout.y) + pad) - z = np.mean(sol.layout.z) if z is None else z - - # plot windfield and turbine stats - _x, _y = np.linspace(*xlim, res), np.linspace(*ylim, res) - xmesh, ymesh = np.meshgrid(_x, _y) - - wsp = sol.windfield.wsp(xmesh, ymesh, np.full_like(xmesh, z)) - ax.imshow( - wsp, extent=[*xlim, *ylim], vmin=0, vmax=2, origin="lower", cmap="RdYlBu_r" - ) - - for (turb_x, turb_y, _), rotor in zip(sol.layout, sol.rotors): - # Draw turbine - R = 0.5 - p = np.array([[0, 0], [+R, -R]]) - rotmat = np.array( - [ - [np.cos(rotor.yaw), -np.sin(rotor.yaw)], - [np.sin(rotor.yaw), np.cos(rotor.yaw)], - ] + zlim = (np.min(sol.layout.z) - pad, np.max(sol.layout.z) + pad) + xz_frame = False + yz_frame = False + if y is not None: + xz_frame = True + _x, _z = np.linspace(*xlim, res), np.linspace(*zlim, res) + xmesh, zmesh = np.meshgrid(_x, _z) + wsp = sol.windfield.wsp(xmesh, np.full_like(xmesh, y), zmesh) + ax.imshow( + wsp, extent=[*xlim, *zlim], vmin=0, vmax=2, origin="lower", cmap="RdYlBu_r" ) - - p = rotmat @ p + np.array([[turb_x], [turb_y]]) - - ax.plot(p[0, :], p[1, :], "k", lw=2) + elif x is not None: + yz_frame = True + _y, _z = np.linspace(*ylim, res), np.linspace(*zlim, res) + ymesh, zmesh = np.meshgrid(_y, _z) + wsp = sol.windfield.wsp(np.full_like(ymesh, x), ymesh, zmesh) + ax.imshow( + wsp, extent=[*ylim, *zlim], vmin=0, vmax=2, origin="lower", cmap="RdYlBu_r" + ) + else: + z = np.mean(sol.layout.z) if z is None else z + _x, _y = np.linspace(*xlim, res), np.linspace(*ylim, res) + xmesh, ymesh = np.meshgrid(_x, _y) + wsp = sol.windfield.wsp(xmesh, ymesh, np.full_like(xmesh, z)) + ax.imshow( + wsp, extent=[*xlim, *ylim], vmin=0, vmax=2, origin="lower", cmap="RdYlBu_r" + ) + + for (turb_x, turb_y, turb_z), rotor in zip(sol.layout, sol.rotors): + # Draw turbine + if yz_frame: + if turb_x == x: + a, b = [turb_y], [turb_z] + ax.scatter([turb_y], [turb_z], c = "k") + else: + R = 0.5 + p = np.array([[0, 0], [+R, -R]]) + alpha = -rotor.tilt if xz_frame else rotor.yaw + rotmat = np.array( + [ + [np.cos(alpha), -np.sin(alpha)], + [np.sin(alpha), np.cos(alpha)], + ] + ) + trans_vec = [[turb_x], [turb_z]] if xz_frame else [[turb_x], [turb_y]] + p = rotmat @ p + np.array(trans_vec) + # add in line for turbine + ax.plot(p[0, :], p[1, :], "k", lw=2) ax.set(frame_on=frame) if axis is False: ax.set(xticks=[], yticks=[]) diff --git a/mitwindfarm/Rotor.py b/mitwindfarm/Rotor.py index 43fd7b7..bdd3356 100644 --- a/mitwindfarm/Rotor.py +++ b/mitwindfarm/Rotor.py @@ -240,7 +240,7 @@ def __init__(self, rotor_grid=None, beta=0.1403, alpha=2.32, couple_x0=False): self._model = UnifiedMomentumTI_x0(beta=beta, alpha=alpha) def __call__( - self, x: float, y: float, z: float, windfield: Windfield, Ctprime, yaw + self, x: float, y: float, z: float, windfield: Windfield, Ctprime, yaw = 0, tilt = 0, ) -> RotorSolution: """ Calculate the rotor solution for given Ctprime and yaw inputs. @@ -263,7 +263,7 @@ def __call__( REWS = self.rotor_grid.average(Us) RETI = np.sqrt(self.rotor_grid.average(TIs**2)) - sol = self._model(Ctprime, yaw, TI=RETI) + sol = self._model(Ctprime, yaw = yaw, tilt = tilt, TI=RETI) # rotor solution is normalised by REWS. Convert normalisation to U_inf and return return RotorSolution( @@ -275,6 +275,8 @@ def __call__( sol.u4 * REWS, sol.v4 * REWS, REWS, + tilt = tilt, + w4 = sol.w4 * REWS, TI=RETI, extra=sol, ) @@ -325,10 +327,6 @@ def __call__(self, x: float, y: float, z: float, windfield: Windfield, pitch, ts Calculate the RotorSolution for given pitch, TSR, and yaw inputs. See above class documentation on __call__ for more details. """ - if tilt != 0: - warnings.warn("Non-zero tilt is not yet implemented for BEM. Setting tilt to zero.", UserWarning) - tilt = 0 - xs_glob = self.xgrid_loc + x ys_glob = self.ygrid_loc + y zs_glob = self.zgrid_loc + z @@ -339,7 +337,7 @@ def __call__(self, x: float, y: float, z: float, windfield: Windfield, pitch, ts RETI = np.sqrt(self._model.geometry.rotor_average(self._model.geometry.annulus_average(TIs**2))) wdir = windfield.wdir(xs_glob, ys_glob, zs_glob) - sol: BEMSolution = self._model(pitch, tsr, yaw, Us / REWS, wdir) + sol: BEMSolution = self._model(pitch, tsr, yaw = yaw, tilt = tilt, U = Us / REWS, wdir = wdir) return RotorSolution( yaw, sol.Cp() * REWS**3, @@ -349,6 +347,8 @@ def __call__(self, x: float, y: float, z: float, windfield: Windfield, pitch, ts sol.u4 * REWS, sol.v4 * REWS, REWS, + tilt = tilt, + w4 = sol.w4 * REWS, TI=RETI, extra=sol, ) @@ -472,30 +472,17 @@ def __init__( ) self.alpha = alpha - def initial_guess(self, Ctprime, yaw, TI): - return super().initial_guess(Ctprime, yaw) - - def residual( - self, x: np.ndarray, Ctprime: float, yaw: float, TI: float = 0 - ): - """ - Returns the residuals of the Unified Momentum Model for the fixed point - iteration. The equations referred to in this function are from the - associated paper. - """ - return super().residual(x, Ctprime, yaw) # TI unused here; decoupled - - def post_process(self, result, Ctprime, yaw, TI): + def post_process(self, result, Ctprime, yaw = 0, tilt = 0, TI = 0, **kwargs): a, u4, v4, _x0, dp = result.x x0 = ( - np.cos(yaw) + np.cos(self.eff_yaw) / 4 * (1 + u4) - * np.sqrt((1 - a) * np.cos(yaw) / (1 + u4)) + * np.sqrt((1 - a) * np.cos(self.eff_yaw) / (1 + u4)) / (self.beta * np.abs(1 - u4) / 2 + self.alpha * TI) ) # re-compute x0 with TI influence decoupled result.x = (a, u4, v4, x0, dp) - return super().post_process(result, Ctprime, yaw) + return super().post_process(result, Ctprime, yaw = yaw, tilt = tilt, **kwargs) class UnifiedMomentumTI(UnifiedMomentum): @@ -507,11 +494,8 @@ def __init__(self, beta=0.1403, alpha=2.32, **kwargs): super().__init__(beta=beta, **kwargs) self.alpha = alpha - def initial_guess(self, Ctprime, yaw, TI): - return super().initial_guess(Ctprime, yaw) - def residual( - self, x: np.ndarray, Ctprime: float, yaw: float, TI: float = 0 + self, x: np.ndarray, Ctprime: float, TI: float = 0, **kwargs ): """ Returns the residuals of the Unified Momentum Model for the fixed point @@ -522,14 +506,14 @@ def residual( if type(Ctprime) is float and Ctprime == 0: return 0 - an, 1 - u4, 0 - v4, 100 - x0, 0 - dp - p_g = self._nonlinear_pressure(Ctprime, yaw, an, x0) + p_g = self._nonlinear_pressure(Ctprime, self.eff_yaw, an, x0) # Eq. 4 - Near wake length in residual form, includes alpha term. e_x0 = ( - np.cos(yaw) + np.cos(self.eff_yaw) / 4 * (1 + u4) - * np.sqrt((1 - an) * np.cos(yaw) / (1 + u4)) + * np.sqrt((1 - an) * np.cos(self.eff_yaw) / (1 + u4)) / (self.beta * np.abs(1 - u4) / 2 + self.alpha * TI) ) - x0 @@ -537,18 +521,18 @@ def residual( e_an = ( 1 - np.sqrt( - -dp / (0.5 * Ctprime * np.cos(yaw) ** 2) - + (1 - u4**2 - v4**2) / (Ctprime * np.cos(yaw) ** 2) + -dp / (0.5 * Ctprime * np.cos(self.eff_yaw) ** 2) + + (1 - u4**2 - v4**2) / (Ctprime * np.cos(self.eff_yaw) ** 2) ) ) - an # Eq. 2 - Streamwise outlet velocity in residual form. e_u4 = ( - -(1 / 4) * Ctprime * (1 - an) * np.cos(yaw) ** 2 + -(1 / 4) * Ctprime * (1 - an) * np.cos(self.eff_yaw) ** 2 + (1 / 2) + (1 / 2) * np.sqrt( - (1 / 2 * Ctprime * (1 - an) * np.cos(yaw) ** 2 - 1) ** 2 - (4 * dp) + (1 / 2 * Ctprime * (1 - an) * np.cos(self.eff_yaw) ** 2 - 1) ** 2 - (4 * dp) ) ) - u4 @@ -558,8 +542,8 @@ def residual( * (1 / 4) * Ctprime * (1 - an) ** 2 - * np.sin(yaw) - * np.cos(yaw) ** 2 + * np.sin(self.eff_yaw) + * np.cos(self.eff_yaw) ** 2 - v4 ) @@ -569,13 +553,10 @@ def residual( -(1 / (2 * np.pi)) * Ctprime * (1 - an) ** 2 - * np.cos(yaw) ** 2 + * np.cos(self.eff_yaw) ** 2 * np.arctan(1 / (2 * x0)) ) + p_g ) - dp - return e_an, e_u4, e_v4, e_x0, e_dp - - def post_process(self, result, Ctprime, yaw, TI): - return super().post_process(result, Ctprime, yaw) + return e_an, e_u4, e_v4, e_x0, e_dp \ No newline at end of file diff --git a/poetry.lock b/poetry.lock index d54d566..a6ca6a8 100644 --- a/poetry.lock +++ b/poetry.lock @@ -2,15 +2,15 @@ [[package]] name = "anyio" -version = "4.9.0" -description = "High level compatibility layer for multiple asynchronous event loop implementations" +version = "4.11.0" +description = "High-level concurrency and networking framework on top of asyncio or Trio" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c"}, - {file = "anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028"}, + {file = "anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc"}, + {file = "anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4"}, ] [package.dependencies] @@ -20,9 +20,7 @@ sniffio = ">=1.1" typing_extensions = {version = ">=4.5", markers = "python_version < \"3.13\""} [package.extras] -doc = ["Sphinx (>=8.2,<9.0)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx_rtd_theme"] -test = ["anyio[trio]", "blockbuster (>=1.5.23)", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "trustme", "truststore (>=0.9.1) ; python_version >= \"3.10\"", "uvloop (>=0.21) ; platform_python_implementation == \"CPython\" and platform_system != \"Windows\" and python_version < \"3.14\""] -trio = ["trio (>=0.26.1)"] +trio = ["trio (>=0.31.0)"] [[package]] name = "appnope" @@ -55,63 +53,67 @@ argon2-cffi-bindings = "*" [[package]] name = "argon2-cffi-bindings" -version = "21.2.0" +version = "25.1.0" description = "Low-level CFFI bindings for Argon2" optional = true -python-versions = ">=3.6" +python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, - {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6"}, + {file = "argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98"}, + {file = "argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94"}, + {file = "argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6dca33a9859abf613e22733131fc9194091c1fa7cb3e131c143056b4856aa47e"}, + {file = "argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:21378b40e1b8d1655dd5310c84a40fc19a9aa5e6366e835ceb8576bf0fea716d"}, + {file = "argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d588dec224e2a83edbdc785a5e6f3c6cd736f46bfd4b441bbb5aa1f5085e584"}, + {file = "argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5acb4e41090d53f17ca1110c3427f0a130f944b896fc8c83973219c97f57b690"}, + {file = "argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:da0c79c23a63723aa5d782250fbf51b768abca630285262fb5144ba5ae01e520"}, + {file = "argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d"}, ] [package.dependencies] -cffi = ">=1.0.1" - -[package.extras] -dev = ["cogapp", "pre-commit", "pytest", "wheel"] -tests = ["pytest"] +cffi = [ + {version = ">=1.0.1", markers = "python_version < \"3.14\""}, + {version = ">=2.0.0b1", markers = "python_version >= \"3.14\""}, +] [[package]] name = "arrow" -version = "1.3.0" +version = "1.4.0" description = "Better dates & times for Python" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, - {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, + {file = "arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205"}, + {file = "arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7"}, ] [package.dependencies] python-dateutil = ">=2.7.0" -types-python-dateutil = ">=2.8.10" +tzdata = {version = "*", markers = "python_version >= \"3.9\""} [package.extras] doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"] -test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"] +test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2025.2)", "simplejson (==3.*)"] [[package]] name = "asttokens" @@ -148,25 +150,17 @@ typing_extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} [[package]] name = "attrs" -version = "25.3.0" +version = "25.4.0" description = "Classes Without Boilerplate" optional = true -python-versions = ">=3.8" +python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3"}, - {file = "attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b"}, + {file = "attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373"}, + {file = "attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11"}, ] -[package.extras] -benchmark = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"] -cov = ["cloudpickle ; platform_python_implementation == \"CPython\"", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"] -dev = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pre-commit-uv", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"] -docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier"] -tests = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"] -tests-mypy = ["mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\""] - [[package]] name = "babel" version = "2.17.0" @@ -185,15 +179,15 @@ dev = ["backports.zoneinfo ; python_version < \"3.9\"", "freezegun (>=1.0,<2.0)" [[package]] name = "beautifulsoup4" -version = "4.13.4" +version = "4.14.2" description = "Screen-scraping library" optional = true python-versions = ">=3.7.0" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "beautifulsoup4-4.13.4-py3-none-any.whl", hash = "sha256:9bbbb14bfde9d79f38b8cd5f8c7c85f4b8f2523190ebed90e950a8dea4cb1c4b"}, - {file = "beautifulsoup4-4.13.4.tar.gz", hash = "sha256:dbb3c4e1ceae6aefebdaf2423247260cd062430a410e38c66f2baa50a8437195"}, + {file = "beautifulsoup4-4.14.2-py3-none-any.whl", hash = "sha256:5ef6fa3a8cbece8488d66985560f97ed091e22bbc4e9c2338508a9d5de6d4515"}, + {file = "beautifulsoup4-4.14.2.tar.gz", hash = "sha256:2a98ab9f944a11acee9cc848508ec28d9228abfd522ef0fad6a02a72e0ded69e"}, ] [package.dependencies] @@ -214,7 +208,7 @@ description = "An easy safelist-based HTML-sanitizing tool." optional = true python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"dev\"" +markers = "python_version < \"3.14\" and extra == \"dev\"" files = [ {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, @@ -227,201 +221,259 @@ webencodings = "*" [package.extras] css = ["tinycss2 (>=1.1.0,<1.5)"] +[[package]] +name = "bleach" +version = "6.3.0" +description = "An easy safelist-based HTML-sanitizing tool." +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and extra == \"dev\"" +files = [ + {file = "bleach-6.3.0-py3-none-any.whl", hash = "sha256:fe10ec77c93ddf3d13a73b035abaac7a9f5e436513864ccdad516693213c65d6"}, + {file = "bleach-6.3.0.tar.gz", hash = "sha256:6f3b91b1c0a02bb9a78b5a454c92506aa0fdf197e1d5e114d2e00c6f64306d22"}, +] + +[package.dependencies] +tinycss2 = {version = ">=1.1.0,<1.5", optional = true, markers = "extra == \"css\""} +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.5)"] + [[package]] name = "certifi" -version = "2025.7.14" +version = "2025.10.5" description = "Python package for providing Mozilla's CA Bundle." optional = true python-versions = ">=3.7" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "certifi-2025.7.14-py3-none-any.whl", hash = "sha256:6b31f564a415d79ee77df69d757bb49a5bb53bd9f756cbbe24394ffd6fc1f4b2"}, - {file = "certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995"}, + {file = "certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de"}, + {file = "certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43"}, ] [[package]] name = "cffi" -version = "1.17.1" +version = "2.0.0" description = "Foreign Function Interface for Python calling C code." optional = true -python-versions = ">=3.8" +python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"}, - {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17"}, - {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8"}, - {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e"}, - {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be"}, - {file = "cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c"}, - {file = "cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15"}, - {file = "cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401"}, - {file = "cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d"}, - {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6"}, - {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f"}, - {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b"}, - {file = "cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655"}, - {file = "cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0"}, - {file = "cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4"}, - {file = "cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93"}, - {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3"}, - {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8"}, - {file = "cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65"}, - {file = "cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903"}, - {file = "cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e"}, - {file = "cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd"}, - {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed"}, - {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9"}, - {file = "cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d"}, - {file = "cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a"}, - {file = "cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1"}, - {file = "cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8"}, - {file = "cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1"}, - {file = "cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16"}, - {file = "cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3"}, - {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595"}, - {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a"}, - {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e"}, - {file = "cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7"}, - {file = "cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662"}, - {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, -] - -[package.dependencies] -pycparser = "*" + {file = "cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44"}, + {file = "cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49"}, + {file = "cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c"}, + {file = "cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb"}, + {file = "cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0"}, + {file = "cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4"}, + {file = "cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453"}, + {file = "cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495"}, + {file = "cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5"}, + {file = "cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb"}, + {file = "cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a"}, + {file = "cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739"}, + {file = "cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe"}, + {file = "cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c"}, + {file = "cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92"}, + {file = "cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93"}, + {file = "cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5"}, + {file = "cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664"}, + {file = "cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26"}, + {file = "cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9"}, + {file = "cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414"}, + {file = "cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743"}, + {file = "cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5"}, + {file = "cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5"}, + {file = "cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d"}, + {file = "cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d"}, + {file = "cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c"}, + {file = "cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe"}, + {file = "cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062"}, + {file = "cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e"}, + {file = "cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037"}, + {file = "cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba"}, + {file = "cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94"}, + {file = "cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187"}, + {file = "cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18"}, + {file = "cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5"}, + {file = "cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6"}, + {file = "cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb"}, + {file = "cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca"}, + {file = "cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b"}, + {file = "cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b"}, + {file = "cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2"}, + {file = "cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3"}, + {file = "cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26"}, + {file = "cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c"}, + {file = "cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b"}, + {file = "cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27"}, + {file = "cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75"}, + {file = "cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91"}, + {file = "cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5"}, + {file = "cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13"}, + {file = "cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b"}, + {file = "cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c"}, + {file = "cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef"}, + {file = "cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775"}, + {file = "cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205"}, + {file = "cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1"}, + {file = "cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f"}, + {file = "cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25"}, + {file = "cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad"}, + {file = "cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9"}, + {file = "cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d"}, + {file = "cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c"}, + {file = "cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8"}, + {file = "cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc"}, + {file = "cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592"}, + {file = "cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512"}, + {file = "cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4"}, + {file = "cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e"}, + {file = "cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6"}, + {file = "cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9"}, + {file = "cffi-2.0.0-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:fe562eb1a64e67dd297ccc4f5addea2501664954f2692b69a76449ec7913ecbf"}, + {file = "cffi-2.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:de8dad4425a6ca6e4e5e297b27b5c824ecc7581910bf9aee86cb6835e6812aa7"}, + {file = "cffi-2.0.0-cp39-cp39-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:4647afc2f90d1ddd33441e5b0e85b16b12ddec4fca55f0d9671fef036ecca27c"}, + {file = "cffi-2.0.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3f4d46d8b35698056ec29bca21546e1551a205058ae1a181d871e278b0b28165"}, + {file = "cffi-2.0.0-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e6e73b9e02893c764e7e8d5bb5ce277f1a009cd5243f8228f75f842bf937c534"}, + {file = "cffi-2.0.0-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:cb527a79772e5ef98fb1d700678fe031e353e765d1ca2d409c92263c6d43e09f"}, + {file = "cffi-2.0.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:61d028e90346df14fedc3d1e5441df818d095f3b87d286825dfcbd6459b7ef63"}, + {file = "cffi-2.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:0f6084a0ea23d05d20c3edcda20c3d006f9b6f3fefeac38f59262e10cef47ee2"}, + {file = "cffi-2.0.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:1cd13c99ce269b3ed80b417dcd591415d3372bcac067009b6e0f59c7d4015e65"}, + {file = "cffi-2.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:89472c9762729b5ae1ad974b777416bfda4ac5642423fa93bd57a09204712322"}, + {file = "cffi-2.0.0-cp39-cp39-win32.whl", hash = "sha256:2081580ebb843f759b9f617314a24ed5738c51d2aee65d31e02f6f7a2b97707a"}, + {file = "cffi-2.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:b882b3df248017dba09d6b16defe9b5c407fe32fc7c65a9c69798e6175601be9"}, + {file = "cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529"}, +] + +[package.dependencies] +pycparser = {version = "*", markers = "implementation_name != \"PyPy\""} [[package]] name = "charset-normalizer" -version = "3.4.2" +version = "3.4.4" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = true python-versions = ">=3.7" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-win32.whl", hash = "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cad5f45b3146325bb38d6855642f6fd609c3f7cad4dbaf75549bf3b904d3184"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b2680962a4848b3c4f155dc2ee64505a9c57186d0d56b43123b17ca3de18f0fa"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:36b31da18b8890a76ec181c3cf44326bf2c48e36d393ca1b72b3f484113ea344"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4074c5a429281bf056ddd4c5d3b740ebca4d43ffffe2ef4bf4d2d05114299da"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c9e36a97bee9b86ef9a1cf7bb96747eb7a15c2f22bdb5b516434b00f2a599f02"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:1b1bde144d98e446b056ef98e59c256e9294f6b74d7af6846bf5ffdafd687a7d"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:915f3849a011c1f593ab99092f3cecfcb4d65d8feb4a64cf1bf2d22074dc0ec4"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:fb707f3e15060adf5b7ada797624a6c6e0138e2a26baa089df64c68ee98e040f"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:25a23ea5c7edc53e0f29bae2c44fcb5a1aa10591aae107f2a2b2583a9c5cbc64"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:770cab594ecf99ae64c236bc9ee3439c3f46be49796e265ce0cc8bc17b10294f"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-win32.whl", hash = "sha256:6a0289e4589e8bdfef02a80478f1dfcb14f0ab696b5a00e1f4b8a14a307a3c58"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6fc1f5b51fa4cecaa18f2bd7a003f3dd039dd615cd69a2afd6d3b19aed6775f2"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:76af085e67e56c8816c3ccf256ebd136def2ed9654525348cfa744b6802b69eb"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e45ba65510e2647721e35323d6ef54c7974959f6081b58d4ef5d87c60c84919a"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:046595208aae0120559a67693ecc65dd75d46f7bf687f159127046628178dc45"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75d10d37a47afee94919c4fab4c22b9bc2a8bf7d4f46f87363bcf0573f3ff4f5"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6333b3aa5a12c26b2a4d4e7335a28f1475e0e5e17d69d55141ee3cab736f66d1"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e8323a9b031aa0393768b87f04b4164a40037fb2a3c11ac06a03ffecd3618027"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:24498ba8ed6c2e0b56d4acbf83f2d989720a93b41d712ebd4f4979660db4417b"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:844da2b5728b5ce0e32d863af26f32b5ce61bc4273a9c720a9f3aa9df73b1455"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:65c981bdbd3f57670af8b59777cbfae75364b483fa8a9f420f08094531d54a01"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:3c21d4fca343c805a52c0c78edc01e3477f6dd1ad7c47653241cf2a206d4fc58"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:dc7039885fa1baf9be153a0626e337aa7ec8bf96b0128605fb0d77788ddc1681"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-win32.whl", hash = "sha256:8272b73e1c5603666618805fe821edba66892e2870058c94c53147602eab29c7"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:70f7172939fdf8790425ba31915bfbe8335030f05b9913d7ae00a87d4395620a"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:005fa3432484527f9732ebd315da8da8001593e2cf46a3d817669f062c3d9ed4"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e92fca20c46e9f5e1bb485887d074918b13543b1c2a1185e69bb8d17ab6236a7"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50bf98d5e563b83cc29471fa114366e6806bc06bc7a25fd59641e41445327836"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:721c76e84fe669be19c5791da68232ca2e05ba5185575086e384352e2c309597"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82d8fd25b7f4675d0c47cf95b594d4e7b158aca33b76aa63d07186e13c0e0ab7"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3daeac64d5b371dea99714f08ffc2c208522ec6b06fbc7866a450dd446f5c0f"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dccab8d5fa1ef9bfba0590ecf4d46df048d18ffe3eec01eeb73a42e0d9e7a8ba"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:aaf27faa992bfee0264dc1f03f4c75e9fcdda66a519db6b957a3f826e285cf12"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:eb30abc20df9ab0814b5a2524f23d75dcf83cde762c161917a2b4b7b55b1e518"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:c72fbbe68c6f32f251bdc08b8611c7b3060612236e960ef848e0a517ddbe76c5"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:982bb1e8b4ffda883b3d0a521e23abcd6fd17418f6d2c4118d257a10199c0ce3"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-win32.whl", hash = "sha256:43e0933a0eff183ee85833f341ec567c0980dae57c464d8a508e1b2ceb336471"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:d11b54acf878eef558599658b0ffca78138c8c3655cf4f3a4a673c437e67732e"}, - {file = "charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0"}, - {file = "charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d"}, + {file = "charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016"}, + {file = "charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525"}, + {file = "charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14"}, + {file = "charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c"}, + {file = "charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ce8a0633f41a967713a59c4139d29110c07e826d131a316b50ce11b1d79b4f84"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaabd426fe94daf8fd157c32e571c85cb12e66692f15516a83a03264b08d06c3"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c4ef880e27901b6cc782f1b95f82da9313c0eb95c3af699103088fa0ac3ce9ac"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aaba3b0819274cc41757a1da876f810a3e4d7b6eb25699253a4effef9e8e4af"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:778d2e08eda00f4256d7f672ca9fef386071c9202f5e4607920b86d7803387f2"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f155a433c2ec037d4e8df17d18922c3a0d9b3232a396690f17175d2946f0218d"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a8bf8d0f749c5757af2142fe7903a9df1d2e8aa3841559b2bad34b08d0e2bcf3"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:194f08cbb32dc406d6e1aea671a68be0823673db2832b38405deba2fb0d88f63"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_armv7l.whl", hash = "sha256:6aee717dcfead04c6eb1ce3bd29ac1e22663cdea57f943c87d1eab9a025438d7"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:cd4b7ca9984e5e7985c12bc60a6f173f3c958eae74f3ef6624bb6b26e2abbae4"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_riscv64.whl", hash = "sha256:b7cf1017d601aa35e6bb650b6ad28652c9cd78ee6caff19f3c28d03e1c80acbf"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:e912091979546adf63357d7e2ccff9b44f026c075aeaf25a52d0e95ad2281074"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:5cb4d72eea50c8868f5288b7f7f33ed276118325c1dfd3957089f6b519e1382a"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-win32.whl", hash = "sha256:837c2ce8c5a65a2035be9b3569c684358dfbf109fd3b6969630a87535495ceaa"}, + {file = "charset_normalizer-3.4.4-cp38-cp38-win_amd64.whl", hash = "sha256:44c2a8734b333e0578090c4cd6b16f275e07aa6614ca8715e6c038e865e70576"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:a9768c477b9d7bd54bc0c86dbaebdec6f03306675526c9927c0e8a04e8f94af9"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1bee1e43c28aa63cb16e5c14e582580546b08e535299b8b6158a7c9c768a1f3d"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:fd44c878ea55ba351104cb93cc85e74916eb8fa440ca7903e57575e97394f608"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0f04b14ffe5fdc8c4933862d8306109a2c51e0704acfa35d51598eb45a1e89fc"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:cd09d08005f958f370f539f186d10aec3377d55b9eeb0d796025d4886119d76e"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4fe7859a4e3e8457458e2ff592f15ccb02f3da787fcd31e0183879c3ad4692a1"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa09f53c465e532f4d3db095e0c55b615f010ad81803d383195b6b5ca6cbf5f3"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7fa17817dc5625de8a027cb8b26d9fefa3ea28c8253929b8d6649e705d2835b6"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:5947809c8a2417be3267efc979c47d76a079758166f7d43ef5ae8e9f92751f88"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:4902828217069c3c5c71094537a8e623f5d097858ac6ca8252f7b4d10b7560f1"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:7c308f7e26e4363d79df40ca5b2be1c6ba9f02bdbccfed5abddb7859a6ce72cf"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:2c9d3c380143a1fedbff95a312aa798578371eb29da42106a29019368a475318"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:cb01158d8b88ee68f15949894ccc6712278243d95f344770fa7593fa2d94410c"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-win32.whl", hash = "sha256:2677acec1a2f8ef614c6888b5b4ae4060cc184174a938ed4e8ef690e15d3e505"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-win_amd64.whl", hash = "sha256:f8e160feb2aed042cd657a72acc0b481212ed28b1b9a95c0cee1621b524e1966"}, + {file = "charset_normalizer-3.4.4-cp39-cp39-win_arm64.whl", hash = "sha256:b5d84d37db046c5ca74ee7bb47dd6cbc13f80665fdde3e8040bdd3fb015ecb50"}, + {file = "charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f"}, + {file = "charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a"}, ] [[package]] @@ -439,20 +491,17 @@ files = [ [[package]] name = "comm" -version = "0.2.2" +version = "0.2.3" description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, - {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, + {file = "comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417"}, + {file = "comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971"}, ] -[package.dependencies] -traitlets = ">=4" - [package.extras] test = ["pytest"] @@ -463,7 +512,7 @@ description = "Python library for calculating contours of 2D quadrilateral grids optional = true python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"dev\" or extra == \"examples\"" +markers = "python_version < \"3.14\" and (extra == \"dev\" or extra == \"examples\")" files = [ {file = "contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7"}, {file = "contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42"}, @@ -542,6 +591,99 @@ mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.11.1)", "types-Pil test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] test-no-images = ["pytest", "pytest-cov", "pytest-rerunfailures", "pytest-xdist", "wurlitzer"] +[[package]] +name = "contourpy" +version = "1.3.3" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = true +python-versions = ">=3.11" +groups = ["main"] +markers = "python_version >= \"3.14\" and (extra == \"dev\" or extra == \"examples\")" +files = [ + {file = "contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1"}, + {file = "contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381"}, + {file = "contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7"}, + {file = "contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1"}, + {file = "contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a"}, + {file = "contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db"}, + {file = "contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620"}, + {file = "contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f"}, + {file = "contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff"}, + {file = "contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42"}, + {file = "contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470"}, + {file = "contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb"}, + {file = "contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6"}, + {file = "contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7"}, + {file = "contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8"}, + {file = "contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea"}, + {file = "contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1"}, + {file = "contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7"}, + {file = "contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411"}, + {file = "contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69"}, + {file = "contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b"}, + {file = "contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc"}, + {file = "contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5"}, + {file = "contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1"}, + {file = "contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286"}, + {file = "contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5"}, + {file = "contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67"}, + {file = "contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9"}, + {file = "contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659"}, + {file = "contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7"}, + {file = "contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d"}, + {file = "contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263"}, + {file = "contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9"}, + {file = "contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d"}, + {file = "contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216"}, + {file = "contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae"}, + {file = "contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20"}, + {file = "contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99"}, + {file = "contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b"}, + {file = "contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a"}, + {file = "contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e"}, + {file = "contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3"}, + {file = "contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8"}, + {file = "contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301"}, + {file = "contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a"}, + {file = "contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77"}, + {file = "contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5"}, + {file = "contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4"}, + {file = "contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36"}, + {file = "contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3"}, + {file = "contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b"}, + {file = "contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36"}, + {file = "contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d"}, + {file = "contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd"}, + {file = "contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339"}, + {file = "contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772"}, + {file = "contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77"}, + {file = "contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13"}, + {file = "contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe"}, + {file = "contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f"}, + {file = "contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0"}, + {file = "contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4"}, + {file = "contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f"}, + {file = "contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae"}, + {file = "contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc"}, + {file = "contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b"}, + {file = "contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497"}, + {file = "contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8"}, + {file = "contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e"}, + {file = "contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989"}, + {file = "contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77"}, + {file = "contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880"}, +] + +[package.dependencies] +numpy = ">=1.25" + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] +mypy = ["bokeh", "contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.17.0)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "pytest-rerunfailures", "pytest-xdist", "wurlitzer"] + [[package]] name = "cycler" version = "0.12.1" @@ -561,39 +703,43 @@ tests = ["pytest", "pytest-cov", "pytest-xdist"] [[package]] name = "debugpy" -version = "1.8.15" +version = "1.8.17" description = "An implementation of the Debug Adapter Protocol for Python" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "debugpy-1.8.15-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:e9a8125c85172e3ec30985012e7a81ea5e70bbb836637f8a4104f454f9b06c97"}, - {file = "debugpy-1.8.15-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fd0b6b5eccaa745c214fd240ea82f46049d99ef74b185a3517dad3ea1ec55d9"}, - {file = "debugpy-1.8.15-cp310-cp310-win32.whl", hash = "sha256:8181cce4d344010f6bfe94a531c351a46a96b0f7987750932b2908e7a1e14a55"}, - {file = "debugpy-1.8.15-cp310-cp310-win_amd64.whl", hash = "sha256:af2dcae4e4cd6e8b35f982ccab29fe65f7e8766e10720a717bc80c464584ee21"}, - {file = "debugpy-1.8.15-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:babc4fb1962dd6a37e94d611280e3d0d11a1f5e6c72ac9b3d87a08212c4b6dd3"}, - {file = "debugpy-1.8.15-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f778e68f2986a58479d0ac4f643e0b8c82fdd97c2e200d4d61e7c2d13838eb53"}, - {file = "debugpy-1.8.15-cp311-cp311-win32.whl", hash = "sha256:f9d1b5abd75cd965e2deabb1a06b0e93a1546f31f9f621d2705e78104377c702"}, - {file = "debugpy-1.8.15-cp311-cp311-win_amd64.whl", hash = "sha256:62954fb904bec463e2b5a415777f6d1926c97febb08ef1694da0e5d1463c5c3b"}, - {file = "debugpy-1.8.15-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:3dcc7225cb317469721ab5136cda9ff9c8b6e6fb43e87c9e15d5b108b99d01ba"}, - {file = "debugpy-1.8.15-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:047a493ca93c85ccede1dbbaf4e66816794bdc214213dde41a9a61e42d27f8fc"}, - {file = "debugpy-1.8.15-cp312-cp312-win32.whl", hash = "sha256:b08e9b0bc260cf324c890626961dad4ffd973f7568fbf57feb3c3a65ab6b6327"}, - {file = "debugpy-1.8.15-cp312-cp312-win_amd64.whl", hash = "sha256:e2a4fe357c92334272eb2845fcfcdbec3ef9f22c16cf613c388ac0887aed15fa"}, - {file = "debugpy-1.8.15-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:f5e01291ad7d6649aed5773256c5bba7a1a556196300232de1474c3c372592bf"}, - {file = "debugpy-1.8.15-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94dc0f0d00e528d915e0ce1c78e771475b2335b376c49afcc7382ee0b146bab6"}, - {file = "debugpy-1.8.15-cp313-cp313-win32.whl", hash = "sha256:fcf0748d4f6e25f89dc5e013d1129ca6f26ad4da405e0723a4f704583896a709"}, - {file = "debugpy-1.8.15-cp313-cp313-win_amd64.whl", hash = "sha256:73c943776cb83e36baf95e8f7f8da765896fd94b05991e7bc162456d25500683"}, - {file = "debugpy-1.8.15-cp38-cp38-macosx_14_0_x86_64.whl", hash = "sha256:054cd4935bd2e4964dfe1aeee4d6bca89d0c833366776fc35387f8a2f517dd00"}, - {file = "debugpy-1.8.15-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21c4288e662997df3176c4b9d93ee1393913fbaf320732be332d538000c53208"}, - {file = "debugpy-1.8.15-cp38-cp38-win32.whl", hash = "sha256:aaa8ce6a37d764f93fe583d7c6ca58eb7550b36941387483db113125f122bb0d"}, - {file = "debugpy-1.8.15-cp38-cp38-win_amd64.whl", hash = "sha256:71cdf7f676af78e70f005c7fad2ef9da0edc2a24befbf3ab146a51f0d58048c2"}, - {file = "debugpy-1.8.15-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:085b6d0adb3eb457c2823ac497a0690b10a99eff8b01c01a041e84579f114b56"}, - {file = "debugpy-1.8.15-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd546a405381d17527814852642df0a74b7da8acc20ae5f3cfad0b7c86419511"}, - {file = "debugpy-1.8.15-cp39-cp39-win32.whl", hash = "sha256:ae0d445fe11ff4351428e6c2389e904e1cdcb4a47785da5a5ec4af6c5b95fce5"}, - {file = "debugpy-1.8.15-cp39-cp39-win_amd64.whl", hash = "sha256:de7db80189ca97ab4b10a87e4039cfe4dd7ddfccc8f33b5ae40fcd33792fc67a"}, - {file = "debugpy-1.8.15-py2.py3-none-any.whl", hash = "sha256:bce2e6c5ff4f2e00b98d45e7e01a49c7b489ff6df5f12d881c67d2f1ac635f3d"}, - {file = "debugpy-1.8.15.tar.gz", hash = "sha256:58d7a20b7773ab5ee6bdfb2e6cf622fdf1e40c9d5aef2857d85391526719ac00"}, + {file = "debugpy-1.8.17-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:c41d2ce8bbaddcc0009cc73f65318eedfa3dbc88a8298081deb05389f1ab5542"}, + {file = "debugpy-1.8.17-cp310-cp310-manylinux_2_34_x86_64.whl", hash = "sha256:1440fd514e1b815edd5861ca394786f90eb24960eb26d6f7200994333b1d79e3"}, + {file = "debugpy-1.8.17-cp310-cp310-win32.whl", hash = "sha256:3a32c0af575749083d7492dc79f6ab69f21b2d2ad4cd977a958a07d5865316e4"}, + {file = "debugpy-1.8.17-cp310-cp310-win_amd64.whl", hash = "sha256:a3aad0537cf4d9c1996434be68c6c9a6d233ac6f76c2a482c7803295b4e4f99a"}, + {file = "debugpy-1.8.17-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:d3fce3f0e3de262a3b67e69916d001f3e767661c6e1ee42553009d445d1cd840"}, + {file = "debugpy-1.8.17-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:c6bdf134457ae0cac6fb68205776be635d31174eeac9541e1d0c062165c6461f"}, + {file = "debugpy-1.8.17-cp311-cp311-win32.whl", hash = "sha256:e79a195f9e059edfe5d8bf6f3749b2599452d3e9380484cd261f6b7cd2c7c4da"}, + {file = "debugpy-1.8.17-cp311-cp311-win_amd64.whl", hash = "sha256:b532282ad4eca958b1b2d7dbcb2b7218e02cb934165859b918e3b6ba7772d3f4"}, + {file = "debugpy-1.8.17-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:f14467edef672195c6f6b8e27ce5005313cb5d03c9239059bc7182b60c176e2d"}, + {file = "debugpy-1.8.17-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:24693179ef9dfa20dca8605905a42b392be56d410c333af82f1c5dff807a64cc"}, + {file = "debugpy-1.8.17-cp312-cp312-win32.whl", hash = "sha256:6a4e9dacf2cbb60d2514ff7b04b4534b0139facbf2abdffe0639ddb6088e59cf"}, + {file = "debugpy-1.8.17-cp312-cp312-win_amd64.whl", hash = "sha256:e8f8f61c518952fb15f74a302e068b48d9c4691768ade433e4adeea961993464"}, + {file = "debugpy-1.8.17-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:857c1dd5d70042502aef1c6d1c2801211f3ea7e56f75e9c335f434afb403e464"}, + {file = "debugpy-1.8.17-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:3bea3b0b12f3946e098cce9b43c3c46e317b567f79570c3f43f0b96d00788088"}, + {file = "debugpy-1.8.17-cp313-cp313-win32.whl", hash = "sha256:e34ee844c2f17b18556b5bbe59e1e2ff4e86a00282d2a46edab73fd7f18f4a83"}, + {file = "debugpy-1.8.17-cp313-cp313-win_amd64.whl", hash = "sha256:6c5cd6f009ad4fca8e33e5238210dc1e5f42db07d4b6ab21ac7ffa904a196420"}, + {file = "debugpy-1.8.17-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:045290c010bcd2d82bc97aa2daf6837443cd52f6328592698809b4549babcee1"}, + {file = "debugpy-1.8.17-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:b69b6bd9dba6a03632534cdf67c760625760a215ae289f7489a452af1031fe1f"}, + {file = "debugpy-1.8.17-cp314-cp314-win32.whl", hash = "sha256:5c59b74aa5630f3a5194467100c3b3d1c77898f9ab27e3f7dc5d40fc2f122670"}, + {file = "debugpy-1.8.17-cp314-cp314-win_amd64.whl", hash = "sha256:893cba7bb0f55161de4365584b025f7064e1f88913551bcd23be3260b231429c"}, + {file = "debugpy-1.8.17-cp38-cp38-macosx_15_0_x86_64.whl", hash = "sha256:8deb4e31cd575c9f9370042876e078ca118117c1b5e1f22c32befcfbb6955f0c"}, + {file = "debugpy-1.8.17-cp38-cp38-manylinux_2_34_x86_64.whl", hash = "sha256:b75868b675949a96ab51abc114c7163f40ff0d8f7d6d5fd63f8932fd38e9c6d7"}, + {file = "debugpy-1.8.17-cp38-cp38-win32.whl", hash = "sha256:17e456da14848d618662354e1dccfd5e5fb75deec3d1d48dc0aa0baacda55860"}, + {file = "debugpy-1.8.17-cp38-cp38-win_amd64.whl", hash = "sha256:e851beb536a427b5df8aa7d0c7835b29a13812f41e46292ff80b2ef77327355a"}, + {file = "debugpy-1.8.17-cp39-cp39-macosx_15_0_x86_64.whl", hash = "sha256:f2ac8055a0c4a09b30b931100996ba49ef334c6947e7ae365cdd870416d7513e"}, + {file = "debugpy-1.8.17-cp39-cp39-manylinux_2_34_x86_64.whl", hash = "sha256:eaa85bce251feca8e4c87ce3b954aba84b8c645b90f0e6a515c00394a9f5c0e7"}, + {file = "debugpy-1.8.17-cp39-cp39-win32.whl", hash = "sha256:b13eea5587e44f27f6c48588b5ad56dcb74a4f3a5f89250443c94587f3eb2ea1"}, + {file = "debugpy-1.8.17-cp39-cp39-win_amd64.whl", hash = "sha256:bb1bbf92317e1f35afcf3ef0450219efb3afe00be79d8664b250ac0933b9015f"}, + {file = "debugpy-1.8.17-py2.py3-none-any.whl", hash = "sha256:60c7dca6571efe660ccb7a9508d73ca14b8796c4ed484c2002abba714226cfef"}, + {file = "debugpy-1.8.17.tar.gz", hash = "sha256:fd723b47a8c08892b1a16b2c6239a8b96637c62a59b94bb5dab4bac592a58a8e"}, ] [[package]] @@ -643,15 +789,15 @@ test = ["pytest (>=6)"] [[package]] name = "executing" -version = "2.2.0" +version = "2.2.1" description = "Get the currently executing AST node of a frame, and other information" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa"}, - {file = "executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755"}, + {file = "executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017"}, + {file = "executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4"}, ] [package.extras] @@ -659,15 +805,15 @@ tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipyth [[package]] name = "fastjsonschema" -version = "2.21.1" +version = "2.21.2" description = "Fastest Python implementation of JSON schema" optional = true python-versions = "*" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667"}, - {file = "fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4"}, + {file = "fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463"}, + {file = "fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de"}, ] [package.extras] @@ -675,55 +821,71 @@ devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benc [[package]] name = "fonttools" -version = "4.59.0" +version = "4.60.1" description = "Tools to manipulate font files" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\" or extra == \"examples\"" files = [ - {file = "fonttools-4.59.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:524133c1be38445c5c0575eacea42dbd44374b310b1ffc4b60ff01d881fabb96"}, - {file = "fonttools-4.59.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:21e606b2d38fed938dde871c5736822dd6bda7a4631b92e509a1f5cd1b90c5df"}, - {file = "fonttools-4.59.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e93df708c69a193fc7987192f94df250f83f3851fda49413f02ba5dded639482"}, - {file = "fonttools-4.59.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:62224a9bb85b4b66d1b46d45cbe43d71cbf8f527d332b177e3b96191ffbc1e64"}, - {file = "fonttools-4.59.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8974b2a266b54c96709bd5e239979cddfd2dbceed331aa567ea1d7c4a2202db"}, - {file = "fonttools-4.59.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:209b75943d158f610b78320eacb5539aa9e920bee2c775445b2846c65d20e19d"}, - {file = "fonttools-4.59.0-cp310-cp310-win32.whl", hash = "sha256:4c908a7036f0f3677f8afa577bcd973e3e20ddd2f7c42a33208d18bee95cdb6f"}, - {file = "fonttools-4.59.0-cp310-cp310-win_amd64.whl", hash = "sha256:8b4309a2775e4feee7356e63b163969a215d663399cce1b3d3b65e7ec2d9680e"}, - {file = "fonttools-4.59.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:841b2186adce48903c0fef235421ae21549020eca942c1da773ac380b056ab3c"}, - {file = "fonttools-4.59.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9bcc1e77fbd1609198966ded6b2a9897bd6c6bcbd2287a2fc7d75f1a254179c5"}, - {file = "fonttools-4.59.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:37c377f7cb2ab2eca8a0b319c68146d34a339792f9420fca6cd49cf28d370705"}, - {file = "fonttools-4.59.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fa39475eaccb98f9199eccfda4298abaf35ae0caec676ffc25b3a5e224044464"}, - {file = "fonttools-4.59.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d3972b13148c1d1fbc092b27678a33b3080d1ac0ca305742b0119b75f9e87e38"}, - {file = "fonttools-4.59.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a408c3c51358c89b29cfa5317cf11518b7ce5de1717abb55c5ae2d2921027de6"}, - {file = "fonttools-4.59.0-cp311-cp311-win32.whl", hash = "sha256:6770d7da00f358183d8fd5c4615436189e4f683bdb6affb02cad3d221d7bb757"}, - {file = "fonttools-4.59.0-cp311-cp311-win_amd64.whl", hash = "sha256:84fc186980231a287b28560d3123bd255d3c6b6659828c642b4cf961e2b923d0"}, - {file = "fonttools-4.59.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f9b3a78f69dcbd803cf2fb3f972779875b244c1115481dfbdd567b2c22b31f6b"}, - {file = "fonttools-4.59.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:57bb7e26928573ee7c6504f54c05860d867fd35e675769f3ce01b52af38d48e2"}, - {file = "fonttools-4.59.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4536f2695fe5c1ffb528d84a35a7d3967e5558d2af58b4775e7ab1449d65767b"}, - {file = "fonttools-4.59.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:885bde7d26e5b40e15c47bd5def48b38cbd50830a65f98122a8fb90962af7cd1"}, - {file = "fonttools-4.59.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6801aeddb6acb2c42eafa45bc1cb98ba236871ae6f33f31e984670b749a8e58e"}, - {file = "fonttools-4.59.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:31003b6a10f70742a63126b80863ab48175fb8272a18ca0846c0482968f0588e"}, - {file = "fonttools-4.59.0-cp312-cp312-win32.whl", hash = "sha256:fbce6dae41b692a5973d0f2158f782b9ad05babc2c2019a970a1094a23909b1b"}, - {file = "fonttools-4.59.0-cp312-cp312-win_amd64.whl", hash = "sha256:332bfe685d1ac58ca8d62b8d6c71c2e52a6c64bc218dc8f7825c9ea51385aa01"}, - {file = "fonttools-4.59.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:78813b49d749e1bb4db1c57f2d4d7e6db22c253cb0a86ad819f5dc197710d4b2"}, - {file = "fonttools-4.59.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:401b1941ce37e78b8fd119b419b617277c65ae9417742a63282257434fd68ea2"}, - {file = "fonttools-4.59.0-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:efd7e6660674e234e29937bc1481dceb7e0336bfae75b856b4fb272b5093c5d4"}, - {file = "fonttools-4.59.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51ab1ff33c19e336c02dee1e9fd1abd974a4ca3d8f7eef2a104d0816a241ce97"}, - {file = "fonttools-4.59.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a9bf8adc9e1f3012edc8f09b08336272aec0c55bc677422273e21280db748f7c"}, - {file = "fonttools-4.59.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:37e01c6ec0c98599778c2e688350d624fa4770fbd6144551bd5e032f1199171c"}, - {file = "fonttools-4.59.0-cp313-cp313-win32.whl", hash = "sha256:70d6b3ceaa9cc5a6ac52884f3b3d9544e8e231e95b23f138bdb78e6d4dc0eae3"}, - {file = "fonttools-4.59.0-cp313-cp313-win_amd64.whl", hash = "sha256:26731739daa23b872643f0e4072d5939960237d540c35c14e6a06d47d71ca8fe"}, - {file = "fonttools-4.59.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8d77f92438daeaddc05682f0f3dac90c5b9829bcac75b57e8ce09cb67786073c"}, - {file = "fonttools-4.59.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:60f6665579e909b618282f3c14fa0b80570fbf1ee0e67678b9a9d43aa5d67a37"}, - {file = "fonttools-4.59.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:169b99a2553a227f7b5fea8d9ecd673aa258617f466b2abc6091fe4512a0dcd0"}, - {file = "fonttools-4.59.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:052444a5d0151878e87e3e512a1aa1a0ab35ee4c28afde0a778e23b0ace4a7de"}, - {file = "fonttools-4.59.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:d40dcf533ca481355aa7b682e9e079f766f35715defa4929aeb5597f9604272e"}, - {file = "fonttools-4.59.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b818db35879d2edf7f46c7e729c700a0bce03b61b9412f5a7118406687cb151d"}, - {file = "fonttools-4.59.0-cp39-cp39-win32.whl", hash = "sha256:2e7cf8044ce2598bb87e44ba1d2c6e45d7a8decf56055b92906dc53f67c76d64"}, - {file = "fonttools-4.59.0-cp39-cp39-win_amd64.whl", hash = "sha256:902425f5afe28572d65d2bf9c33edd5265c612ff82c69e6f83ea13eafc0dcbea"}, - {file = "fonttools-4.59.0-py3-none-any.whl", hash = "sha256:241313683afd3baacb32a6bd124d0bce7404bc5280e12e291bae1b9bba28711d"}, - {file = "fonttools-4.59.0.tar.gz", hash = "sha256:be392ec3529e2f57faa28709d60723a763904f71a2b63aabe14fee6648fe3b14"}, + {file = "fonttools-4.60.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:9a52f254ce051e196b8fe2af4634c2d2f02c981756c6464dc192f1b6050b4e28"}, + {file = "fonttools-4.60.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c7420a2696a44650120cdd269a5d2e56a477e2bfa9d95e86229059beb1c19e15"}, + {file = "fonttools-4.60.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee0c0b3b35b34f782afc673d503167157094a16f442ace7c6c5e0ca80b08f50c"}, + {file = "fonttools-4.60.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:282dafa55f9659e8999110bd8ed422ebe1c8aecd0dc396550b038e6c9a08b8ea"}, + {file = "fonttools-4.60.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4ba4bd646e86de16160f0fb72e31c3b9b7d0721c3e5b26b9fa2fc931dfdb2652"}, + {file = "fonttools-4.60.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0b0835ed15dd5b40d726bb61c846a688f5b4ce2208ec68779bc81860adb5851a"}, + {file = "fonttools-4.60.1-cp310-cp310-win32.whl", hash = "sha256:1525796c3ffe27bb6268ed2a1bb0dcf214d561dfaf04728abf01489eb5339dce"}, + {file = "fonttools-4.60.1-cp310-cp310-win_amd64.whl", hash = "sha256:268ecda8ca6cb5c4f044b1fb9b3b376e8cd1b361cef275082429dc4174907038"}, + {file = "fonttools-4.60.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7b4c32e232a71f63a5d00259ca3d88345ce2a43295bb049d21061f338124246f"}, + {file = "fonttools-4.60.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3630e86c484263eaac71d117085d509cbcf7b18f677906824e4bace598fb70d2"}, + {file = "fonttools-4.60.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5c1015318e4fec75dd4943ad5f6a206d9727adf97410d58b7e32ab644a807914"}, + {file = "fonttools-4.60.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e6c58beb17380f7c2ea181ea11e7db8c0ceb474c9dd45f48e71e2cb577d146a1"}, + {file = "fonttools-4.60.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ec3681a0cb34c255d76dd9d865a55f260164adb9fa02628415cdc2d43ee2c05d"}, + {file = "fonttools-4.60.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f4b5c37a5f40e4d733d3bbaaef082149bee5a5ea3156a785ff64d949bd1353fa"}, + {file = "fonttools-4.60.1-cp311-cp311-win32.whl", hash = "sha256:398447f3d8c0c786cbf1209711e79080a40761eb44b27cdafffb48f52bcec258"}, + {file = "fonttools-4.60.1-cp311-cp311-win_amd64.whl", hash = "sha256:d066ea419f719ed87bc2c99a4a4bfd77c2e5949cb724588b9dd58f3fd90b92bf"}, + {file = "fonttools-4.60.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7b0c6d57ab00dae9529f3faf187f2254ea0aa1e04215cf2f1a8ec277c96661bc"}, + {file = "fonttools-4.60.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:839565cbf14645952d933853e8ade66a463684ed6ed6c9345d0faf1f0e868877"}, + {file = "fonttools-4.60.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8177ec9676ea6e1793c8a084a90b65a9f778771998eb919d05db6d4b1c0b114c"}, + {file = "fonttools-4.60.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:996a4d1834524adbb423385d5a629b868ef9d774670856c63c9a0408a3063401"}, + {file = "fonttools-4.60.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a46b2f450bc79e06ef3b6394f0c68660529ed51692606ad7f953fc2e448bc903"}, + {file = "fonttools-4.60.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6ec722ee589e89a89f5b7574f5c45604030aa6ae24cb2c751e2707193b466fed"}, + {file = "fonttools-4.60.1-cp312-cp312-win32.whl", hash = "sha256:b2cf105cee600d2de04ca3cfa1f74f1127f8455b71dbad02b9da6ec266e116d6"}, + {file = "fonttools-4.60.1-cp312-cp312-win_amd64.whl", hash = "sha256:992775c9fbe2cf794786fa0ffca7f09f564ba3499b8fe9f2f80bd7197db60383"}, + {file = "fonttools-4.60.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f68576bb4bbf6060c7ab047b1574a1ebe5c50a17de62830079967b211059ebb"}, + {file = "fonttools-4.60.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:eedacb5c5d22b7097482fa834bda0dafa3d914a4e829ec83cdea2a01f8c813c4"}, + {file = "fonttools-4.60.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b33a7884fabd72bdf5f910d0cf46be50dce86a0362a65cfc746a4168c67eb96c"}, + {file = "fonttools-4.60.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2409d5fb7b55fd70f715e6d34e7a6e4f7511b8ad29a49d6df225ee76da76dd77"}, + {file = "fonttools-4.60.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c8651e0d4b3bdeda6602b85fdc2abbefc1b41e573ecb37b6779c4ca50753a199"}, + {file = "fonttools-4.60.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:145daa14bf24824b677b9357c5e44fd8895c2a8f53596e1b9ea3496081dc692c"}, + {file = "fonttools-4.60.1-cp313-cp313-win32.whl", hash = "sha256:2299df884c11162617a66b7c316957d74a18e3758c0274762d2cc87df7bc0272"}, + {file = "fonttools-4.60.1-cp313-cp313-win_amd64.whl", hash = "sha256:a3db56f153bd4c5c2b619ab02c5db5192e222150ce5a1bc10f16164714bc39ac"}, + {file = "fonttools-4.60.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:a884aef09d45ba1206712c7dbda5829562d3fea7726935d3289d343232ecb0d3"}, + {file = "fonttools-4.60.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8a44788d9d91df72d1a5eac49b31aeb887a5f4aab761b4cffc4196c74907ea85"}, + {file = "fonttools-4.60.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e852d9dda9f93ad3651ae1e3bb770eac544ec93c3807888798eccddf84596537"}, + {file = "fonttools-4.60.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:154cb6ee417e417bf5f7c42fe25858c9140c26f647c7347c06f0cc2d47eff003"}, + {file = "fonttools-4.60.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5664fd1a9ea7f244487ac8f10340c4e37664675e8667d6fee420766e0fb3cf08"}, + {file = "fonttools-4.60.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:583b7f8e3c49486e4d489ad1deacfb8d5be54a8ef34d6df824f6a171f8511d99"}, + {file = "fonttools-4.60.1-cp314-cp314-win32.whl", hash = "sha256:66929e2ea2810c6533a5184f938502cfdaea4bc3efb7130d8cc02e1c1b4108d6"}, + {file = "fonttools-4.60.1-cp314-cp314-win_amd64.whl", hash = "sha256:f3d5be054c461d6a2268831f04091dc82753176f6ea06dc6047a5e168265a987"}, + {file = "fonttools-4.60.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:b6379e7546ba4ae4b18f8ae2b9bc5960936007a1c0e30b342f662577e8bc3299"}, + {file = "fonttools-4.60.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9d0ced62b59e0430b3690dbc5373df1c2aa7585e9a8ce38eff87f0fd993c5b01"}, + {file = "fonttools-4.60.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:875cb7764708b3132637f6c5fb385b16eeba0f7ac9fa45a69d35e09b47045801"}, + {file = "fonttools-4.60.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a184b2ea57b13680ab6d5fbde99ccef152c95c06746cb7718c583abd8f945ccc"}, + {file = "fonttools-4.60.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:026290e4ec76583881763fac284aca67365e0be9f13a7fb137257096114cb3bc"}, + {file = "fonttools-4.60.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f0e8817c7d1a0c2eedebf57ef9a9896f3ea23324769a9a2061a80fe8852705ed"}, + {file = "fonttools-4.60.1-cp314-cp314t-win32.whl", hash = "sha256:1410155d0e764a4615774e5c2c6fc516259fe3eca5882f034eb9bfdbee056259"}, + {file = "fonttools-4.60.1-cp314-cp314t-win_amd64.whl", hash = "sha256:022beaea4b73a70295b688f817ddc24ed3e3418b5036ffcd5658141184ef0d0c"}, + {file = "fonttools-4.60.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:122e1a8ada290423c493491d002f622b1992b1ab0b488c68e31c413390dc7eb2"}, + {file = "fonttools-4.60.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a140761c4ff63d0cb9256ac752f230460ee225ccef4ad8f68affc723c88e2036"}, + {file = "fonttools-4.60.1-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0eae96373e4b7c9e45d099d7a523444e3554360927225c1cdae221a58a45b856"}, + {file = "fonttools-4.60.1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:596ecaca36367027d525b3b426d8a8208169d09edcf8c7506aceb3a38bfb55c7"}, + {file = "fonttools-4.60.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2ee06fc57512144d8b0445194c2da9f190f61ad51e230f14836286470c99f854"}, + {file = "fonttools-4.60.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b42d86938e8dda1cd9a1a87a6d82f1818eaf933348429653559a458d027446da"}, + {file = "fonttools-4.60.1-cp39-cp39-win32.whl", hash = "sha256:8b4eb332f9501cb1cd3d4d099374a1e1306783ff95489a1026bde9eb02ccc34a"}, + {file = "fonttools-4.60.1-cp39-cp39-win_amd64.whl", hash = "sha256:7473a8ed9ed09aeaa191301244a5a9dbe46fe0bf54f9d6cd21d83044c3321217"}, + {file = "fonttools-4.60.1-py3-none-any.whl", hash = "sha256:906306ac7afe2156fcf0042173d6ebbb05416af70f6b370967b47f8f00103bbb"}, + {file = "fonttools-4.60.1.tar.gz", hash = "sha256:ef00af0439ebfee806b25f24c8f92109157ff3fac5731dc7867957812e87b8d9"}, ] [package.extras] @@ -831,15 +993,15 @@ zstd = ["zstandard (>=0.18.0)"] [[package]] name = "idna" -version = "3.10" +version = "3.11" description = "Internationalized Domain Names in Applications (IDNA)" optional = true -python-versions = ">=3.6" +python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, - {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, + {file = "idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea"}, + {file = "idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902"}, ] [package.extras] @@ -901,23 +1063,36 @@ description = "brain-dead simple config-ini parsing" optional = true python-versions = ">=3.8" groups = ["main"] -markers = "extra == \"dev\"" +markers = "python_version < \"3.14\" and extra == \"dev\"" files = [ {file = "iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760"}, {file = "iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7"}, ] +[[package]] +name = "iniconfig" +version = "2.3.0" +description = "brain-dead simple config-ini parsing" +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and extra == \"dev\"" +files = [ + {file = "iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12"}, + {file = "iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730"}, +] + [[package]] name = "ipykernel" -version = "6.30.0" +version = "6.31.0" description = "IPython Kernel for Jupyter" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "ipykernel-6.30.0-py3-none-any.whl", hash = "sha256:fd2936e55c4a1c2ee8b1e5fa6a372b8eecc0ab1338750dee76f48fa5cca1301e"}, - {file = "ipykernel-6.30.0.tar.gz", hash = "sha256:b7b808ddb2d261aae2df3a26ff3ff810046e6de3dfbc6f7de8c98ea0a6cb632c"}, + {file = "ipykernel-6.31.0-py3-none-any.whl", hash = "sha256:abe5386f6ced727a70e0eb0cf1da801fa7c5fa6ff82147747d5a0406cd8c94af"}, + {file = "ipykernel-6.31.0.tar.gz", hash = "sha256:2372ce8bc1ff4f34e58cafed3a0feb2194b91fc7cad0fc72e79e47b45ee9e8f6"}, ] [package.dependencies] @@ -949,7 +1124,7 @@ description = "IPython: Productive Interactive Computing" optional = true python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"dev\"" +markers = "python_version < \"3.14\" and extra == \"dev\"" files = [ {file = "ipython-8.18.1-py3-none-any.whl", hash = "sha256:e8267419d72d81955ec1177f8a29aaa90ac80ad647499201119e2f05e99aa397"}, {file = "ipython-8.18.1.tar.gz", hash = "sha256:ca6f079bb33457c66e233e4580ebfc4128855b4cf6370dddd73842a9563e8a27"}, @@ -981,6 +1156,44 @@ qtconsole = ["qtconsole"] test = ["pickleshare", "pytest (<7.1)", "pytest-asyncio (<0.22)", "testpath"] test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.22)", "pandas", "pickleshare", "pytest (<7.1)", "pytest-asyncio (<0.22)", "testpath", "trio"] +[[package]] +name = "ipython" +version = "8.37.0" +description = "IPython: Productive Interactive Computing" +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and extra == \"dev\"" +files = [ + {file = "ipython-8.37.0-py3-none-any.whl", hash = "sha256:ed87326596b878932dbcb171e3e698845434d8c61b8d8cd474bf663041a9dcf2"}, + {file = "ipython-8.37.0.tar.gz", hash = "sha256:ca815841e1a41a1e6b73a0b08f3038af9b2252564d01fc405356d34033012216"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""} +prompt_toolkit = ">=3.0.41,<3.1.0" +pygments = ">=2.4.0" +stack_data = "*" +traitlets = ">=5.13.0" + +[package.extras] +all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "intersphinx_registry", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "tomli ; python_version < \"3.11\"", "typing_extensions"] +kernel = ["ipykernel"] +matplotlib = ["matplotlib"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["packaging", "pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] +test-extra = ["curio", "ipython[test]", "jupyter_ai", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] + [[package]] name = "ipywidgets" version = "8.1.7" @@ -1062,15 +1275,15 @@ i18n = ["Babel (>=2.7)"] [[package]] name = "json5" -version = "0.12.0" +version = "0.12.1" description = "A Python implementation of the JSON5 data format." optional = true python-versions = ">=3.8.0" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "json5-0.12.0-py3-none-any.whl", hash = "sha256:6d37aa6c08b0609f16e1ec5ff94697e2cbbfbad5ac112afa05794da9ab7810db"}, - {file = "json5-0.12.0.tar.gz", hash = "sha256:0b4b6ff56801a1c7dc817b0241bca4ce474a0e6a163bfef3fc594d3fd263ff3a"}, + {file = "json5-0.12.1-py3-none-any.whl", hash = "sha256:d9c9b3bc34a5f54d43c35e11ef7cb87d8bdd098c6ace87117a7b7e83e705c1d5"}, + {file = "json5-0.12.1.tar.gz", hash = "sha256:b2743e77b3242f8d03c143dd975a6ec7c52e2f2afe76ed934e53503dd4ad4990"}, ] [package.extras] @@ -1091,15 +1304,15 @@ files = [ [[package]] name = "jsonschema" -version = "4.25.0" +version = "4.25.1" description = "An implementation of JSON Schema validation for Python" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "jsonschema-4.25.0-py3-none-any.whl", hash = "sha256:24c2e8da302de79c8b9382fee3e76b355e44d2a4364bb207159ce10b517bd716"}, - {file = "jsonschema-4.25.0.tar.gz", hash = "sha256:e63acf5c11762c0e6672ffb61482bdf57f0876684d8d249c0fe2d730d48bc55f"}, + {file = "jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63"}, + {file = "jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85"}, ] [package.dependencies] @@ -1123,15 +1336,15 @@ format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339- [[package]] name = "jsonschema-specifications" -version = "2025.4.1" +version = "2025.9.1" description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "jsonschema_specifications-2025.4.1-py3-none-any.whl", hash = "sha256:4653bffbd6584f7de83a67e0d620ef16900b390ddc7939d56684d6c81e33f1af"}, - {file = "jsonschema_specifications-2025.4.1.tar.gz", hash = "sha256:630159c9f4dbea161a6a2205c3011cc4f18ff381b189fff48bb39b9bf26ae608"}, + {file = "jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe"}, + {file = "jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d"}, ] [package.dependencies] @@ -1216,7 +1429,7 @@ description = "Jupyter core package. A base package on which Jupyter projects re optional = true python-versions = ">=3.8" groups = ["main"] -markers = "extra == \"dev\"" +markers = "python_version < \"3.14\" and extra == \"dev\"" files = [ {file = "jupyter_core-5.8.1-py3-none-any.whl", hash = "sha256:c28d268fc90fb53f1338ded2eb410704c5449a358406e8a948b75706e24863d0"}, {file = "jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941"}, @@ -1231,6 +1444,27 @@ traitlets = ">=5.3" docs = ["intersphinx-registry", "myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-spelling", "traitlets"] test = ["ipykernel", "pre-commit", "pytest (<9)", "pytest-cov", "pytest-timeout"] +[[package]] +name = "jupyter-core" +version = "5.9.1" +description = "Jupyter core package. A base package on which Jupyter projects rely." +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and extra == \"dev\"" +files = [ + {file = "jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407"}, + {file = "jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508"}, +] + +[package.dependencies] +platformdirs = ">=2.5" +traitlets = ">=5.3" + +[package.extras] +docs = ["intersphinx-registry", "myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-spelling", "traitlets"] +test = ["ipykernel", "pre-commit", "pytest (<9)", "pytest-cov", "pytest-timeout"] + [[package]] name = "jupyter-events" version = "0.12.0" @@ -1261,15 +1495,15 @@ test = ["click", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "p [[package]] name = "jupyter-lsp" -version = "2.2.6" +version = "2.3.0" description = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "jupyter_lsp-2.2.6-py3-none-any.whl", hash = "sha256:283783752bf0b459ee7fa88effa72104d87dd343b82d5c06cf113ef755b15b6d"}, - {file = "jupyter_lsp-2.2.6.tar.gz", hash = "sha256:0566bd9bb04fd9e6774a937ed01522b555ba78be37bebef787c8ab22de4c0361"}, + {file = "jupyter_lsp-2.3.0-py3-none-any.whl", hash = "sha256:e914a3cb2addf48b1c7710914771aaf1819d46b2e5a79b0f917b5478ec93f34f"}, + {file = "jupyter_lsp-2.3.0.tar.gz", hash = "sha256:458aa59339dc868fb784d73364f17dbce8836e906cd75fd471a325cba02e0245"}, ] [package.dependencies] @@ -1278,15 +1512,15 @@ jupyter_server = ">=1.1.2" [[package]] name = "jupyter-server" -version = "2.16.0" +version = "2.17.0" description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "jupyter_server-2.16.0-py3-none-any.whl", hash = "sha256:3d8db5be3bc64403b1c65b400a1d7f4647a5ce743f3b20dbdefe8ddb7b55af9e"}, - {file = "jupyter_server-2.16.0.tar.gz", hash = "sha256:65d4b44fdf2dcbbdfe0aa1ace4a842d4aaf746a2b7b168134d5aaed35621b7f6"}, + {file = "jupyter_server-2.17.0-py3-none-any.whl", hash = "sha256:e8cb9c7db4251f51ed307e329b81b72ccf2056ff82d50524debde1ee1870e13f"}, + {file = "jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5"}, ] [package.dependencies] @@ -1299,7 +1533,7 @@ jupyter-events = ">=0.11.0" jupyter-server-terminals = ">=0.4.4" nbconvert = ">=6.4.4" nbformat = ">=5.3.0" -overrides = ">=5.0" +overrides = {version = ">=5.0", markers = "python_version < \"3.12\""} packaging = ">=22.0" prometheus-client = ">=0.9" pywinpty = {version = ">=2.0.1", markers = "os_name == \"nt\""} @@ -1337,22 +1571,22 @@ test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (> [[package]] name = "jupyterlab" -version = "4.4.5" +version = "4.4.10" description = "JupyterLab computational environment" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "jupyterlab-4.4.5-py3-none-any.whl", hash = "sha256:e76244cceb2d1fb4a99341f3edc866f2a13a9e14c50368d730d75d8017be0863"}, - {file = "jupyterlab-4.4.5.tar.gz", hash = "sha256:0bd6c18e6a3c3d91388af6540afa3d0bb0b2e76287a7b88ddf20ab41b336e595"}, + {file = "jupyterlab-4.4.10-py3-none-any.whl", hash = "sha256:65939ab4c8dcd0c42185c2d0d1a9d60b254dc8c46fc4fdb286b63c51e9358e07"}, + {file = "jupyterlab-4.4.10.tar.gz", hash = "sha256:521c017508af4e1d6d9d8a9d90f47a11c61197ad63b2178342489de42540a615"}, ] [package.dependencies] async-lru = ">=1.0.0" -httpx = ">=0.25.0" +httpx = ">=0.25.0,<1" importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} -ipykernel = ">=6.5.0" +ipykernel = ">=6.5.0,<6.30.0 || >6.30.0" jinja2 = ">=3.0.3" jupyter-core = "*" jupyter-lsp = ">=2.0.0" @@ -1387,15 +1621,15 @@ files = [ [[package]] name = "jupyterlab-server" -version = "2.27.3" +version = "2.28.0" description = "A set of server components for JupyterLab and JupyterLab like applications." optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, - {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, + {file = "jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968"}, + {file = "jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c"}, ] [package.dependencies] @@ -1433,7 +1667,7 @@ description = "A fast implementation of the Cassowary constraint solver" optional = true python-versions = ">=3.8" groups = ["main"] -markers = "extra == \"dev\" or extra == \"examples\"" +markers = "python_version < \"3.14\" and (extra == \"dev\" or extra == \"examples\")" files = [ {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6"}, {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17"}, @@ -1551,17 +1785,129 @@ files = [ {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, ] +[[package]] +name = "kiwisolver" +version = "1.4.9" +description = "A fast implementation of the Cassowary constraint solver" +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and (extra == \"dev\" or extra == \"examples\")" +files = [ + {file = "kiwisolver-1.4.9-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b4b4d74bda2b8ebf4da5bd42af11d02d04428b2c32846e4c2c93219df8a7987b"}, + {file = "kiwisolver-1.4.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fb3b8132019ea572f4611d770991000d7f58127560c4889729248eb5852a102f"}, + {file = "kiwisolver-1.4.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:84fd60810829c27ae375114cd379da1fa65e6918e1da405f356a775d49a62bcf"}, + {file = "kiwisolver-1.4.9-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b78efa4c6e804ecdf727e580dbb9cba85624d2e1c6b5cb059c66290063bd99a9"}, + {file = "kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4efec7bcf21671db6a3294ff301d2fc861c31faa3c8740d1a94689234d1b415"}, + {file = "kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:90f47e70293fc3688b71271100a1a5453aa9944a81d27ff779c108372cf5567b"}, + {file = "kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fdca1def57a2e88ef339de1737a1449d6dbf5fab184c54a1fca01d541317154"}, + {file = "kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9cf554f21be770f5111a1690d42313e140355e687e05cf82cb23d0a721a64a48"}, + {file = "kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1795ac5cd0510207482c3d1d3ed781143383b8cfd36f5c645f3897ce066220"}, + {file = "kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ccd09f20ccdbbd341b21a67ab50a119b64a403b09288c27481575105283c1586"}, + {file = "kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:540c7c72324d864406a009d72f5d6856f49693db95d1fbb46cf86febef873634"}, + {file = "kiwisolver-1.4.9-cp310-cp310-win_amd64.whl", hash = "sha256:ede8c6d533bc6601a47ad4046080d36b8fc99f81e6f1c17b0ac3c2dc91ac7611"}, + {file = "kiwisolver-1.4.9-cp310-cp310-win_arm64.whl", hash = "sha256:7b4da0d01ac866a57dd61ac258c5607b4cd677f63abaec7b148354d2b2cdd536"}, + {file = "kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16"}, + {file = "kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089"}, + {file = "kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543"}, + {file = "kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61"}, + {file = "kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1"}, + {file = "kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872"}, + {file = "kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26"}, + {file = "kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028"}, + {file = "kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771"}, + {file = "kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a"}, + {file = "kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464"}, + {file = "kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2"}, + {file = "kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7"}, + {file = "kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999"}, + {file = "kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2"}, + {file = "kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14"}, + {file = "kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04"}, + {file = "kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752"}, + {file = "kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77"}, + {file = "kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198"}, + {file = "kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d"}, + {file = "kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab"}, + {file = "kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2"}, + {file = "kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145"}, + {file = "kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54"}, + {file = "kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60"}, + {file = "kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8"}, + {file = "kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2"}, + {file = "kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f"}, + {file = "kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098"}, + {file = "kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed"}, + {file = "kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525"}, + {file = "kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78"}, + {file = "kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b"}, + {file = "kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799"}, + {file = "kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3"}, + {file = "kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c"}, + {file = "kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d"}, + {file = "kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07"}, + {file = "kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c"}, + {file = "kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386"}, + {file = "kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552"}, + {file = "kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3"}, + {file = "kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58"}, + {file = "kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4"}, + {file = "kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df"}, + {file = "kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6"}, + {file = "kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5"}, + {file = "kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf"}, + {file = "kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5"}, + {file = "kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce"}, + {file = "kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7"}, + {file = "kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891"}, + {file = "kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32"}, + {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4d1d9e582ad4d63062d34077a9a1e9f3c34088a2ec5135b1f7190c07cf366527"}, + {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:deed0c7258ceb4c44ad5ec7d9918f9f14fd05b2be86378d86cf50e63d1e7b771"}, + {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a590506f303f512dff6b7f75fd2fd18e16943efee932008fe7140e5fa91d80e"}, + {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e09c2279a4d01f099f52d5c4b3d9e208e91edcbd1a175c9662a8b16e000fece9"}, + {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c9e7cdf45d594ee04d5be1b24dd9d49f3d1590959b2271fb30b5ca2b262c00fb"}, + {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5"}, + {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa"}, + {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2"}, + {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f"}, + {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1"}, + {file = "kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d"}, +] + [[package]] name = "lark" -version = "1.2.2" +version = "1.3.1" description = "a modern parsing library" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "lark-1.2.2-py3-none-any.whl", hash = "sha256:c2276486b02f0f1b90be155f2c8ba4a8e194d42775786db622faccd652d8e80c"}, - {file = "lark-1.2.2.tar.gz", hash = "sha256:ca807d0162cd16cef15a8feecb862d7319e7a09bdb13aef927968e45040fed80"}, + {file = "lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12"}, + {file = "lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905"}, ] [package.extras] @@ -1572,74 +1918,102 @@ regex = ["regex"] [[package]] name = "markupsafe" -version = "3.0.2" +version = "3.0.3" description = "Safely add untrusted strings to HTML/XML markup." optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a"}, - {file = "markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0"}, + {file = "markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559"}, + {file = "markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419"}, + {file = "markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695"}, + {file = "markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591"}, + {file = "markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c"}, + {file = "markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f"}, + {file = "markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6"}, + {file = "markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1"}, + {file = "markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa"}, + {file = "markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8"}, + {file = "markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1"}, + {file = "markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad"}, + {file = "markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a"}, + {file = "markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50"}, + {file = "markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf"}, + {file = "markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f"}, + {file = "markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a"}, + {file = "markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115"}, + {file = "markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a"}, + {file = "markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19"}, + {file = "markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01"}, + {file = "markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c"}, + {file = "markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e"}, + {file = "markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce"}, + {file = "markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d"}, + {file = "markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d"}, + {file = "markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a"}, + {file = "markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b"}, + {file = "markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f"}, + {file = "markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b"}, + {file = "markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d"}, + {file = "markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c"}, + {file = "markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f"}, + {file = "markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795"}, + {file = "markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219"}, + {file = "markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6"}, + {file = "markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676"}, + {file = "markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9"}, + {file = "markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1"}, + {file = "markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc"}, + {file = "markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12"}, + {file = "markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed"}, + {file = "markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5"}, + {file = "markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485"}, + {file = "markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73"}, + {file = "markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37"}, + {file = "markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19"}, + {file = "markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025"}, + {file = "markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6"}, + {file = "markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f"}, + {file = "markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb"}, + {file = "markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009"}, + {file = "markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354"}, + {file = "markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218"}, + {file = "markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287"}, + {file = "markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe"}, + {file = "markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026"}, + {file = "markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737"}, + {file = "markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97"}, + {file = "markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d"}, + {file = "markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda"}, + {file = "markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf"}, + {file = "markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe"}, + {file = "markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9"}, + {file = "markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581"}, + {file = "markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4"}, + {file = "markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab"}, + {file = "markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175"}, + {file = "markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634"}, + {file = "markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50"}, + {file = "markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e"}, + {file = "markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5"}, + {file = "markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523"}, + {file = "markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc"}, + {file = "markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d"}, + {file = "markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9"}, + {file = "markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa"}, + {file = "markupsafe-3.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15d939a21d546304880945ca1ecb8a039db6b4dc49b2c5a400387cdae6a62e26"}, + {file = "markupsafe-3.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f71a396b3bf33ecaa1626c255855702aca4d3d9fea5e051b41ac59a9c1c41edc"}, + {file = "markupsafe-3.0.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f4b68347f8c5eab4a13419215bdfd7f8c9b19f2b25520968adfad23eb0ce60c"}, + {file = "markupsafe-3.0.3-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8fc20152abba6b83724d7ff268c249fa196d8259ff481f3b1476383f8f24e42"}, + {file = "markupsafe-3.0.3-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:949b8d66bc381ee8b007cd945914c721d9aba8e27f71959d750a46f7c282b20b"}, + {file = "markupsafe-3.0.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:3537e01efc9d4dccdf77221fb1cb3b8e1a38d5428920e0657ce299b20324d758"}, + {file = "markupsafe-3.0.3-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:591ae9f2a647529ca990bc681daebdd52c8791ff06c2bfa05b65163e28102ef2"}, + {file = "markupsafe-3.0.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a320721ab5a1aba0a233739394eb907f8c8da5c98c9181d1161e77a0c8e36f2d"}, + {file = "markupsafe-3.0.3-cp39-cp39-win32.whl", hash = "sha256:df2449253ef108a379b8b5d6b43f4b1a8e81a061d6537becd5582fba5f9196d7"}, + {file = "markupsafe-3.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:7c3fb7d25180895632e5d3148dbdc29ea38ccb7fd210aa27acbd1201a1902c6e"}, + {file = "markupsafe-3.0.3-cp39-cp39-win_arm64.whl", hash = "sha256:38664109c14ffc9e7437e86b4dceb442b0096dfe3541d7864d9cbe1da4cf36c8"}, + {file = "markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698"}, ] [[package]] @@ -1649,7 +2023,7 @@ description = "Python plotting package" optional = true python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"dev\" or extra == \"examples\"" +markers = "python_version < \"3.14\" and (extra == \"dev\" or extra == \"examples\")" files = [ {file = "matplotlib-3.9.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c5fdd7abfb706dfa8d307af64a87f1a862879ec3cd8d0ec8637458f0885b9c50"}, {file = "matplotlib-3.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d89bc4e85e40a71d1477780366c27fb7c6494d293e1617788986f74e2a03d7ff"}, @@ -1709,33 +2083,116 @@ python-dateutil = ">=2.7" [package.extras] dev = ["meson-python (>=0.13.1,<0.17.0)", "numpy (>=1.25)", "pybind11 (>=2.6,!=2.13.3)", "setuptools (>=64)", "setuptools_scm (>=7)"] +[[package]] +name = "matplotlib" +version = "3.10.7" +description = "Python plotting package" +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and (extra == \"dev\" or extra == \"examples\")" +files = [ + {file = "matplotlib-3.10.7-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7ac81eee3b7c266dd92cee1cd658407b16c57eed08c7421fa354ed68234de380"}, + {file = "matplotlib-3.10.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:667ecd5d8d37813a845053d8f5bf110b534c3c9f30e69ebd25d4701385935a6d"}, + {file = "matplotlib-3.10.7-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc1c51b846aca49a5a8b44fbba6a92d583a35c64590ad9e1e950dc88940a4297"}, + {file = "matplotlib-3.10.7-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a11c2e9e72e7de09b7b72e62f3df23317c888299c875e2b778abf1eda8c0a42"}, + {file = "matplotlib-3.10.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f19410b486fdd139885ace124e57f938c1e6a3210ea13dd29cab58f5d4bc12c7"}, + {file = "matplotlib-3.10.7-cp310-cp310-win_amd64.whl", hash = "sha256:b498e9e4022f93de2d5a37615200ca01297ceebbb56fe4c833f46862a490f9e3"}, + {file = "matplotlib-3.10.7-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:53b492410a6cd66c7a471de6c924f6ede976e963c0f3097a3b7abfadddc67d0a"}, + {file = "matplotlib-3.10.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d9749313deb729f08207718d29c86246beb2ea3fdba753595b55901dee5d2fd6"}, + {file = "matplotlib-3.10.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2222c7ba2cbde7fe63032769f6eb7e83ab3227f47d997a8453377709b7fe3a5a"}, + {file = "matplotlib-3.10.7-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e91f61a064c92c307c5a9dc8c05dc9f8a68f0a3be199d9a002a0622e13f874a1"}, + {file = "matplotlib-3.10.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6f1851eab59ca082c95df5a500106bad73672645625e04538b3ad0f69471ffcc"}, + {file = "matplotlib-3.10.7-cp311-cp311-win_amd64.whl", hash = "sha256:6516ce375109c60ceec579e699524e9d504cd7578506f01150f7a6bc174a775e"}, + {file = "matplotlib-3.10.7-cp311-cp311-win_arm64.whl", hash = "sha256:b172db79759f5f9bc13ef1c3ef8b9ee7b37b0247f987fbbbdaa15e4f87fd46a9"}, + {file = "matplotlib-3.10.7-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a0edb7209e21840e8361e91ea84ea676658aa93edd5f8762793dec77a4a6748"}, + {file = "matplotlib-3.10.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c380371d3c23e0eadf8ebff114445b9f970aff2010198d498d4ab4c3b41eea4f"}, + {file = "matplotlib-3.10.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d5f256d49fea31f40f166a5e3131235a5d2f4b7f44520b1cf0baf1ce568ccff0"}, + {file = "matplotlib-3.10.7-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11ae579ac83cdf3fb72573bb89f70e0534de05266728740d478f0f818983c695"}, + {file = "matplotlib-3.10.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4c14b6acd16cddc3569a2d515cfdd81c7a68ac5639b76548cfc1a9e48b20eb65"}, + {file = "matplotlib-3.10.7-cp312-cp312-win_amd64.whl", hash = "sha256:0d8c32b7ea6fb80b1aeff5a2ceb3fb9778e2759e899d9beff75584714afcc5ee"}, + {file = "matplotlib-3.10.7-cp312-cp312-win_arm64.whl", hash = "sha256:5f3f6d315dcc176ba7ca6e74c7768fb7e4cf566c49cb143f6bc257b62e634ed8"}, + {file = "matplotlib-3.10.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1d9d3713a237970569156cfb4de7533b7c4eacdd61789726f444f96a0d28f57f"}, + {file = "matplotlib-3.10.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37a1fea41153dd6ee061d21ab69c9cf2cf543160b1b85d89cd3d2e2a7902ca4c"}, + {file = "matplotlib-3.10.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b3c4ea4948d93c9c29dc01c0c23eef66f2101bf75158c291b88de6525c55c3d1"}, + {file = "matplotlib-3.10.7-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22df30ffaa89f6643206cf13877191c63a50e8f800b038bc39bee9d2d4957632"}, + {file = "matplotlib-3.10.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b69676845a0a66f9da30e87f48be36734d6748024b525ec4710be40194282c84"}, + {file = "matplotlib-3.10.7-cp313-cp313-win_amd64.whl", hash = "sha256:744991e0cc863dd669c8dc9136ca4e6e0082be2070b9d793cbd64bec872a6815"}, + {file = "matplotlib-3.10.7-cp313-cp313-win_arm64.whl", hash = "sha256:fba2974df0bf8ce3c995fa84b79cde38326e0f7b5409e7a3a481c1141340bcf7"}, + {file = "matplotlib-3.10.7-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:932c55d1fa7af4423422cb6a492a31cbcbdbe68fd1a9a3f545aa5e7a143b5355"}, + {file = "matplotlib-3.10.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e38c2d581d62ee729a6e144c47a71b3f42fb4187508dbbf4fe71d5612c3433b"}, + {file = "matplotlib-3.10.7-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:786656bb13c237bbcebcd402f65f44dd61ead60ee3deb045af429d889c8dbc67"}, + {file = "matplotlib-3.10.7-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09d7945a70ea43bf9248f4b6582734c2fe726723204a76eca233f24cffc7ef67"}, + {file = "matplotlib-3.10.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d0b181e9fa8daf1d9f2d4c547527b167cb8838fc587deabca7b5c01f97199e84"}, + {file = "matplotlib-3.10.7-cp313-cp313t-win_amd64.whl", hash = "sha256:31963603041634ce1a96053047b40961f7a29eb8f9a62e80cc2c0427aa1d22a2"}, + {file = "matplotlib-3.10.7-cp313-cp313t-win_arm64.whl", hash = "sha256:aebed7b50aa6ac698c90f60f854b47e48cd2252b30510e7a1feddaf5a3f72cbf"}, + {file = "matplotlib-3.10.7-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d883460c43e8c6b173fef244a2341f7f7c0e9725c7fe68306e8e44ed9c8fb100"}, + {file = "matplotlib-3.10.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07124afcf7a6504eafcb8ce94091c5898bbdd351519a1beb5c45f7a38c67e77f"}, + {file = "matplotlib-3.10.7-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c17398b709a6cce3d9fdb1595c33e356d91c098cd9486cb2cc21ea2ea418e715"}, + {file = "matplotlib-3.10.7-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7146d64f561498764561e9cd0ed64fcf582e570fc519e6f521e2d0cfd43365e1"}, + {file = "matplotlib-3.10.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90ad854c0a435da3104c01e2c6f0028d7e719b690998a2333d7218db80950722"}, + {file = "matplotlib-3.10.7-cp314-cp314-win_amd64.whl", hash = "sha256:4645fc5d9d20ffa3a39361fcdbcec731382763b623b72627806bf251b6388866"}, + {file = "matplotlib-3.10.7-cp314-cp314-win_arm64.whl", hash = "sha256:9257be2f2a03415f9105c486d304a321168e61ad450f6153d77c69504ad764bb"}, + {file = "matplotlib-3.10.7-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1e4bbad66c177a8fdfa53972e5ef8be72a5f27e6a607cec0d8579abd0f3102b1"}, + {file = "matplotlib-3.10.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d8eb7194b084b12feb19142262165832fc6ee879b945491d1c3d4660748020c4"}, + {file = "matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d41379b05528091f00e1728004f9a8d7191260f3862178b88e8fd770206318"}, + {file = "matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a74f79fafb2e177f240579bc83f0b60f82cc47d2f1d260f422a0627207008ca"}, + {file = "matplotlib-3.10.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:702590829c30aada1e8cef0568ddbffa77ca747b4d6e36c6d173f66e301f89cc"}, + {file = "matplotlib-3.10.7-cp314-cp314t-win_amd64.whl", hash = "sha256:f79d5de970fc90cd5591f60053aecfce1fcd736e0303d9f0bf86be649fa68fb8"}, + {file = "matplotlib-3.10.7-cp314-cp314t-win_arm64.whl", hash = "sha256:cb783436e47fcf82064baca52ce748af71725d0352e1d31564cbe9c95df92b9c"}, + {file = "matplotlib-3.10.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5c09cf8f2793f81368f49f118b6f9f937456362bee282eac575cca7f84cda537"}, + {file = "matplotlib-3.10.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:de66744b2bb88d5cd27e80dfc2ec9f0517d0a46d204ff98fe9e5f2864eb67657"}, + {file = "matplotlib-3.10.7-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:53cc80662dd197ece414dd5b66e07370201515a3eaf52e7c518c68c16814773b"}, + {file = "matplotlib-3.10.7-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:15112bcbaef211bd663fa935ec33313b948e214454d949b723998a43357b17b0"}, + {file = "matplotlib-3.10.7-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d2a959c640cdeecdd2ec3136e8ea0441da59bcaf58d67e9c590740addba2cb68"}, + {file = "matplotlib-3.10.7-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3886e47f64611046bc1db523a09dd0a0a6bed6081e6f90e13806dd1d1d1b5e91"}, + {file = "matplotlib-3.10.7.tar.gz", hash = "sha256:a06ba7e2a2ef9131c79c49e63dad355d2d878413a0376c1727c8b9335ff731c7"}, +] + +[package.dependencies] +contourpy = ">=1.0.1" +cycler = ">=0.10" +fonttools = ">=4.22.0" +kiwisolver = ">=1.3.1" +numpy = ">=1.23" +packaging = ">=20.0" +pillow = ">=8" +pyparsing = ">=3" +python-dateutil = ">=2.7" + +[package.extras] +dev = ["meson-python (>=0.13.1,<0.17.0)", "pybind11 (>=2.13.2,!=2.13.3)", "setuptools (>=64)", "setuptools_scm (>=7)"] + [[package]] name = "matplotlib-inline" -version = "0.1.7" +version = "0.2.1" description = "Inline Matplotlib backend for Jupyter" optional = true -python-versions = ">=3.8" +python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, - {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, + {file = "matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76"}, + {file = "matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe"}, ] [package.dependencies] traitlets = "*" +[package.extras] +test = ["flake8", "nbdime", "nbval", "notebook", "pytest"] + [[package]] name = "mistune" -version = "3.1.3" +version = "3.1.4" description = "A sane and fast Markdown parser with useful plugins and renderers" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "mistune-3.1.3-py3-none-any.whl", hash = "sha256:1a32314113cff28aa6432e99e522677c8587fd83e3d51c29b82a52409c842bd9"}, - {file = "mistune-3.1.3.tar.gz", hash = "sha256:a7035c21782b2becb6be62f8f25d3df81ccb4d6fa477a6525b15af06539f02a0"}, + {file = "mistune-3.1.4-py3-none-any.whl", hash = "sha256:93691da911e5d9d2e23bc54472892aff676df27a75274962ff9edc210364266d"}, + {file = "mistune-3.1.4.tar.gz", hash = "sha256:b5a7f801d389f724ec702840c11d8fc48f2b33519102fc7ee739e8177b672164"}, ] [package.dependencies] @@ -1743,7 +2200,7 @@ typing-extensions = {version = "*", markers = "python_version < \"3.11\""} [[package]] name = "mitrotor" -version = "0.1.1" +version = "0.2.1" description = "" optional = false python-versions = "^3.8" @@ -1761,49 +2218,55 @@ unified-momentum-model = {git = "https://github.com/Howland-Lab/Unified-Momentum type = "git" url = "https://github.com/Howland-Lab/MITRotor.git" reference = "HEAD" -resolved_reference = "0c44d3ea70b609ee4cd5646d036c235600a45c2f" +resolved_reference = "452992865f68f7a74a19fdab55b36f9bf77328d0" [[package]] name = "mypy" -version = "1.17.0" +version = "1.18.2" description = "Optional static typing for Python" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "mypy-1.17.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f8e08de6138043108b3b18f09d3f817a4783912e48828ab397ecf183135d84d6"}, - {file = "mypy-1.17.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce4a17920ec144647d448fc43725b5873548b1aae6c603225626747ededf582d"}, - {file = "mypy-1.17.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6ff25d151cc057fdddb1cb1881ef36e9c41fa2a5e78d8dd71bee6e4dcd2bc05b"}, - {file = "mypy-1.17.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93468cf29aa9a132bceb103bd8475f78cacde2b1b9a94fd978d50d4bdf616c9a"}, - {file = "mypy-1.17.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:98189382b310f16343151f65dd7e6867386d3e35f7878c45cfa11383d175d91f"}, - {file = "mypy-1.17.0-cp310-cp310-win_amd64.whl", hash = "sha256:c004135a300ab06a045c1c0d8e3f10215e71d7b4f5bb9a42ab80236364429937"}, - {file = "mypy-1.17.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9d4fe5c72fd262d9c2c91c1117d16aac555e05f5beb2bae6a755274c6eec42be"}, - {file = "mypy-1.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d96b196e5c16f41b4f7736840e8455958e832871990c7ba26bf58175e357ed61"}, - {file = "mypy-1.17.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:73a0ff2dd10337ceb521c080d4147755ee302dcde6e1a913babd59473904615f"}, - {file = "mypy-1.17.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24cfcc1179c4447854e9e406d3af0f77736d631ec87d31c6281ecd5025df625d"}, - {file = "mypy-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3c56f180ff6430e6373db7a1d569317675b0a451caf5fef6ce4ab365f5f2f6c3"}, - {file = "mypy-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:eafaf8b9252734400f9b77df98b4eee3d2eecab16104680d51341c75702cad70"}, - {file = "mypy-1.17.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f986f1cab8dbec39ba6e0eaa42d4d3ac6686516a5d3dccd64be095db05ebc6bb"}, - {file = "mypy-1.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:51e455a54d199dd6e931cd7ea987d061c2afbaf0960f7f66deef47c90d1b304d"}, - {file = "mypy-1.17.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3204d773bab5ff4ebbd1f8efa11b498027cd57017c003ae970f310e5b96be8d8"}, - {file = "mypy-1.17.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1051df7ec0886fa246a530ae917c473491e9a0ba6938cfd0ec2abc1076495c3e"}, - {file = "mypy-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f773c6d14dcc108a5b141b4456b0871df638eb411a89cd1c0c001fc4a9d08fc8"}, - {file = "mypy-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:1619a485fd0e9c959b943c7b519ed26b712de3002d7de43154a489a2d0fd817d"}, - {file = "mypy-1.17.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c41aa59211e49d717d92b3bb1238c06d387c9325d3122085113c79118bebb06"}, - {file = "mypy-1.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e69db1fb65b3114f98c753e3930a00514f5b68794ba80590eb02090d54a5d4a"}, - {file = "mypy-1.17.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:03ba330b76710f83d6ac500053f7727270b6b8553b0423348ffb3af6f2f7b889"}, - {file = "mypy-1.17.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:037bc0f0b124ce46bfde955c647f3e395c6174476a968c0f22c95a8d2f589bba"}, - {file = "mypy-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c38876106cb6132259683632b287238858bd58de267d80defb6f418e9ee50658"}, - {file = "mypy-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:d30ba01c0f151998f367506fab31c2ac4527e6a7b2690107c7a7f9e3cb419a9c"}, - {file = "mypy-1.17.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:63e751f1b5ab51d6f3d219fe3a2fe4523eaa387d854ad06906c63883fde5b1ab"}, - {file = "mypy-1.17.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f7fb09d05e0f1c329a36dcd30e27564a3555717cde87301fae4fb542402ddfad"}, - {file = "mypy-1.17.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b72c34ce05ac3a1361ae2ebb50757fb6e3624032d91488d93544e9f82db0ed6c"}, - {file = "mypy-1.17.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:434ad499ad8dde8b2f6391ddfa982f41cb07ccda8e3c67781b1bfd4e5f9450a8"}, - {file = "mypy-1.17.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f105f61a5eff52e137fd73bee32958b2add9d9f0a856f17314018646af838e97"}, - {file = "mypy-1.17.0-cp39-cp39-win_amd64.whl", hash = "sha256:ba06254a5a22729853209550d80f94e28690d5530c661f9416a68ac097b13fc4"}, - {file = "mypy-1.17.0-py3-none-any.whl", hash = "sha256:15d9d0018237ab058e5de3d8fce61b6fa72cc59cc78fd91f1b474bce12abf496"}, - {file = "mypy-1.17.0.tar.gz", hash = "sha256:e5d7ccc08ba089c06e2f5629c660388ef1fee708444f1dee0b9203fa031dee03"}, + {file = "mypy-1.18.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c1eab0cf6294dafe397c261a75f96dc2c31bffe3b944faa24db5def4e2b0f77c"}, + {file = "mypy-1.18.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7a780ca61fc239e4865968ebc5240bb3bf610ef59ac398de9a7421b54e4a207e"}, + {file = "mypy-1.18.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:448acd386266989ef11662ce3c8011fd2a7b632e0ec7d61a98edd8e27472225b"}, + {file = "mypy-1.18.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f9e171c465ad3901dc652643ee4bffa8e9fef4d7d0eece23b428908c77a76a66"}, + {file = "mypy-1.18.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:592ec214750bc00741af1f80cbf96b5013d81486b7bb24cb052382c19e40b428"}, + {file = "mypy-1.18.2-cp310-cp310-win_amd64.whl", hash = "sha256:7fb95f97199ea11769ebe3638c29b550b5221e997c63b14ef93d2e971606ebed"}, + {file = "mypy-1.18.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:807d9315ab9d464125aa9fcf6d84fde6e1dc67da0b6f80e7405506b8ac72bc7f"}, + {file = "mypy-1.18.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:776bb00de1778caf4db739c6e83919c1d85a448f71979b6a0edd774ea8399341"}, + {file = "mypy-1.18.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1379451880512ffce14505493bd9fe469e0697543717298242574882cf8cdb8d"}, + {file = "mypy-1.18.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1331eb7fd110d60c24999893320967594ff84c38ac6d19e0a76c5fd809a84c86"}, + {file = "mypy-1.18.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ca30b50a51e7ba93b00422e486cbb124f1c56a535e20eff7b2d6ab72b3b2e37"}, + {file = "mypy-1.18.2-cp311-cp311-win_amd64.whl", hash = "sha256:664dc726e67fa54e14536f6e1224bcfce1d9e5ac02426d2326e2bb4e081d1ce8"}, + {file = "mypy-1.18.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:33eca32dd124b29400c31d7cf784e795b050ace0e1f91b8dc035672725617e34"}, + {file = "mypy-1.18.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a3c47adf30d65e89b2dcd2fa32f3aeb5e94ca970d2c15fcb25e297871c8e4764"}, + {file = "mypy-1.18.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d6c838e831a062f5f29d11c9057c6009f60cb294fea33a98422688181fe2893"}, + {file = "mypy-1.18.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01199871b6110a2ce984bde85acd481232d17413868c9807e95c1b0739a58914"}, + {file = "mypy-1.18.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a2afc0fa0b0e91b4599ddfe0f91e2c26c2b5a5ab263737e998d6817874c5f7c8"}, + {file = "mypy-1.18.2-cp312-cp312-win_amd64.whl", hash = "sha256:d8068d0afe682c7c4897c0f7ce84ea77f6de953262b12d07038f4d296d547074"}, + {file = "mypy-1.18.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:07b8b0f580ca6d289e69209ec9d3911b4a26e5abfde32228a288eb79df129fcc"}, + {file = "mypy-1.18.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ed4482847168439651d3feee5833ccedbf6657e964572706a2adb1f7fa4dfe2e"}, + {file = "mypy-1.18.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3ad2afadd1e9fea5cf99a45a822346971ede8685cc581ed9cd4d42eaf940986"}, + {file = "mypy-1.18.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a431a6f1ef14cf8c144c6b14793a23ec4eae3db28277c358136e79d7d062f62d"}, + {file = "mypy-1.18.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7ab28cc197f1dd77a67e1c6f35cd1f8e8b73ed2217e4fc005f9e6a504e46e7ba"}, + {file = "mypy-1.18.2-cp313-cp313-win_amd64.whl", hash = "sha256:0e2785a84b34a72ba55fb5daf079a1003a34c05b22238da94fcae2bbe46f3544"}, + {file = "mypy-1.18.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:62f0e1e988ad41c2a110edde6c398383a889d95b36b3e60bcf155f5164c4fdce"}, + {file = "mypy-1.18.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8795a039bab805ff0c1dfdb8cd3344642c2b99b8e439d057aba30850b8d3423d"}, + {file = "mypy-1.18.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6ca1e64b24a700ab5ce10133f7ccd956a04715463d30498e64ea8715236f9c9c"}, + {file = "mypy-1.18.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d924eef3795cc89fecf6bedc6ed32b33ac13e8321344f6ddbf8ee89f706c05cb"}, + {file = "mypy-1.18.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20c02215a080e3a2be3aa50506c67242df1c151eaba0dcbc1e4e557922a26075"}, + {file = "mypy-1.18.2-cp314-cp314-win_amd64.whl", hash = "sha256:749b5f83198f1ca64345603118a6f01a4e99ad4bf9d103ddc5a3200cc4614adf"}, + {file = "mypy-1.18.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:25a9c8fb67b00599f839cf472713f54249a62efd53a54b565eb61956a7e3296b"}, + {file = "mypy-1.18.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c2b9c7e284ee20e7598d6f42e13ca40b4928e6957ed6813d1ab6348aa3f47133"}, + {file = "mypy-1.18.2-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6985ed057513e344e43a26cc1cd815c7a94602fb6a3130a34798625bc2f07b6"}, + {file = "mypy-1.18.2-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22f27105f1525ec024b5c630c0b9f36d5c1cc4d447d61fe51ff4bd60633f47ac"}, + {file = "mypy-1.18.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:030c52d0ea8144e721e49b1f68391e39553d7451f0c3f8a7565b59e19fcb608b"}, + {file = "mypy-1.18.2-cp39-cp39-win_amd64.whl", hash = "sha256:aa5e07ac1a60a253445797e42b8b2963c9675563a94f11291ab40718b016a7a0"}, + {file = "mypy-1.18.2-py3-none-any.whl", hash = "sha256:22a1748707dd62b58d2ae53562ffc4d7f8bcc727e8ac7cbc69c053ddc874d47e"}, + {file = "mypy-1.18.2.tar.gz", hash = "sha256:06a398102a5f203d7477b2923dda3634c36727fa5c237d8f859ef90c42a9924b"}, ] [package.dependencies] @@ -1933,20 +2396,20 @@ files = [ [[package]] name = "notebook" -version = "7.4.4" +version = "7.4.7" description = "Jupyter Notebook - A web-based notebook environment for interactive computing" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "notebook-7.4.4-py3-none-any.whl", hash = "sha256:32840f7f777b6bff79bb101159336e9b332bdbfba1495b8739e34d1d65cbc1c0"}, - {file = "notebook-7.4.4.tar.gz", hash = "sha256:392fd501e266f2fb3466c6fcd3331163a2184968cb5c5accf90292e01dfe528c"}, + {file = "notebook-7.4.7-py3-none-any.whl", hash = "sha256:362b7c95527f7dd3c4c84d410b782872fd9c734fb2524c11dd92758527b6eda6"}, + {file = "notebook-7.4.7.tar.gz", hash = "sha256:3f0a04027dfcee8a876de48fba13ab77ec8c12f72f848a222ed7f5081b9e342a"}, ] [package.dependencies] jupyter-server = ">=2.4.0,<3" -jupyterlab = ">=4.4.4,<4.5" +jupyterlab = ">=4.4.9,<4.5" jupyterlab-server = ">=2.27.1,<3" notebook-shim = ">=0.2,<0.3" tornado = ">=6.2.0" @@ -1982,6 +2445,7 @@ description = "Fundamental package for array computing in Python" optional = false python-versions = ">=3.9" groups = ["main"] +markers = "python_version < \"3.14\"" files = [ {file = "numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece"}, {file = "numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04"}, @@ -2030,6 +2494,91 @@ files = [ {file = "numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78"}, ] +[[package]] +name = "numpy" +version = "2.3.4" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.11" +groups = ["main"] +markers = "python_version >= \"3.14\"" +files = [ + {file = "numpy-2.3.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e78aecd2800b32e8347ce49316d3eaf04aed849cd5b38e0af39f829a4e59f5eb"}, + {file = "numpy-2.3.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7fd09cc5d65bda1e79432859c40978010622112e9194e581e3415a3eccc7f43f"}, + {file = "numpy-2.3.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:1b219560ae2c1de48ead517d085bc2d05b9433f8e49d0955c82e8cd37bd7bf36"}, + {file = "numpy-2.3.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:bafa7d87d4c99752d07815ed7a2c0964f8ab311eb8168f41b910bd01d15b6032"}, + {file = "numpy-2.3.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36dc13af226aeab72b7abad501d370d606326a0029b9f435eacb3b8c94b8a8b7"}, + {file = "numpy-2.3.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7b2f9a18b5ff9824a6af80de4f37f4ec3c2aab05ef08f51c77a093f5b89adda"}, + {file = "numpy-2.3.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9984bd645a8db6ca15d850ff996856d8762c51a2239225288f08f9050ca240a0"}, + {file = "numpy-2.3.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:64c5825affc76942973a70acf438a8ab618dbd692b84cd5ec40a0a0509edc09a"}, + {file = "numpy-2.3.4-cp311-cp311-win32.whl", hash = "sha256:ed759bf7a70342f7817d88376eb7142fab9fef8320d6019ef87fae05a99874e1"}, + {file = "numpy-2.3.4-cp311-cp311-win_amd64.whl", hash = "sha256:faba246fb30ea2a526c2e9645f61612341de1a83fb1e0c5edf4ddda5a9c10996"}, + {file = "numpy-2.3.4-cp311-cp311-win_arm64.whl", hash = "sha256:4c01835e718bcebe80394fd0ac66c07cbb90147ebbdad3dcecd3f25de2ae7e2c"}, + {file = "numpy-2.3.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef1b5a3e808bc40827b5fa2c8196151a4c5abe110e1726949d7abddfe5c7ae11"}, + {file = "numpy-2.3.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c2f91f496a87235c6aaf6d3f3d89b17dba64996abadccb289f48456cff931ca9"}, + {file = "numpy-2.3.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f77e5b3d3da652b474cc80a14084927a5e86a5eccf54ca8ca5cbd697bf7f2667"}, + {file = "numpy-2.3.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ab1c5f5ee40d6e01cbe96de5863e39b215a4d24e7d007cad56c7184fdf4aeef"}, + {file = "numpy-2.3.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77b84453f3adcb994ddbd0d1c5d11db2d6bda1a2b7fd5ac5bd4649d6f5dc682e"}, + {file = "numpy-2.3.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4121c5beb58a7f9e6dfdee612cb24f4df5cd4db6e8261d7f4d7450a997a65d6a"}, + {file = "numpy-2.3.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:65611ecbb00ac9846efe04db15cbe6186f562f6bb7e5e05f077e53a599225d16"}, + {file = "numpy-2.3.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dabc42f9c6577bcc13001b8810d300fe814b4cfbe8a92c873f269484594f9786"}, + {file = "numpy-2.3.4-cp312-cp312-win32.whl", hash = "sha256:a49d797192a8d950ca59ee2d0337a4d804f713bb5c3c50e8db26d49666e351dc"}, + {file = "numpy-2.3.4-cp312-cp312-win_amd64.whl", hash = "sha256:985f1e46358f06c2a09921e8921e2c98168ed4ae12ccd6e5e87a4f1857923f32"}, + {file = "numpy-2.3.4-cp312-cp312-win_arm64.whl", hash = "sha256:4635239814149e06e2cb9db3dd584b2fa64316c96f10656983b8026a82e6e4db"}, + {file = "numpy-2.3.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c090d4860032b857d94144d1a9976b8e36709e40386db289aaf6672de2a81966"}, + {file = "numpy-2.3.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a13fc473b6db0be619e45f11f9e81260f7302f8d180c49a22b6e6120022596b3"}, + {file = "numpy-2.3.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:3634093d0b428e6c32c3a69b78e554f0cd20ee420dcad5a9f3b2a63762ce4197"}, + {file = "numpy-2.3.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:043885b4f7e6e232d7df4f51ffdef8c36320ee9d5f227b380ea636722c7ed12e"}, + {file = "numpy-2.3.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ee6a571d1e4f0ea6d5f22d6e5fbd6ed1dc2b18542848e1e7301bd190500c9d7"}, + {file = "numpy-2.3.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fc8a63918b04b8571789688b2780ab2b4a33ab44bfe8ccea36d3eba51228c953"}, + {file = "numpy-2.3.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:40cc556d5abbc54aabe2b1ae287042d7bdb80c08edede19f0c0afb36ae586f37"}, + {file = "numpy-2.3.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ecb63014bb7f4ce653f8be7f1df8cbc6093a5a2811211770f6606cc92b5a78fd"}, + {file = "numpy-2.3.4-cp313-cp313-win32.whl", hash = "sha256:e8370eb6925bb8c1c4264fec52b0384b44f675f191df91cbe0140ec9f0955646"}, + {file = "numpy-2.3.4-cp313-cp313-win_amd64.whl", hash = "sha256:56209416e81a7893036eea03abcb91c130643eb14233b2515c90dcac963fe99d"}, + {file = "numpy-2.3.4-cp313-cp313-win_arm64.whl", hash = "sha256:a700a4031bc0fd6936e78a752eefb79092cecad2599ea9c8039c548bc097f9bc"}, + {file = "numpy-2.3.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:86966db35c4040fdca64f0816a1c1dd8dbd027d90fca5a57e00e1ca4cd41b879"}, + {file = "numpy-2.3.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:838f045478638b26c375ee96ea89464d38428c69170360b23a1a50fa4baa3562"}, + {file = "numpy-2.3.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d7315ed1dab0286adca467377c8381cd748f3dc92235f22a7dfc42745644a96a"}, + {file = "numpy-2.3.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:84f01a4d18b2cc4ade1814a08e5f3c907b079c847051d720fad15ce37aa930b6"}, + {file = "numpy-2.3.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:817e719a868f0dacde4abdfc5c1910b301877970195db9ab6a5e2c4bd5b121f7"}, + {file = "numpy-2.3.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85e071da78d92a214212cacea81c6da557cab307f2c34b5f85b628e94803f9c0"}, + {file = "numpy-2.3.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2ec646892819370cf3558f518797f16597b4e4669894a2ba712caccc9da53f1f"}, + {file = "numpy-2.3.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:035796aaaddfe2f9664b9a9372f089cfc88bd795a67bd1bfe15e6e770934cf64"}, + {file = "numpy-2.3.4-cp313-cp313t-win32.whl", hash = "sha256:fea80f4f4cf83b54c3a051f2f727870ee51e22f0248d3114b8e755d160b38cfb"}, + {file = "numpy-2.3.4-cp313-cp313t-win_amd64.whl", hash = "sha256:15eea9f306b98e0be91eb344a94c0e630689ef302e10c2ce5f7e11905c704f9c"}, + {file = "numpy-2.3.4-cp313-cp313t-win_arm64.whl", hash = "sha256:b6c231c9c2fadbae4011ca5e7e83e12dc4a5072f1a1d85a0a7b3ed754d145a40"}, + {file = "numpy-2.3.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:81c3e6d8c97295a7360d367f9f8553973651b76907988bb6066376bc2252f24e"}, + {file = "numpy-2.3.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7c26b0b2bf58009ed1f38a641f3db4be8d960a417ca96d14e5b06df1506d41ff"}, + {file = "numpy-2.3.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:62b2198c438058a20b6704351b35a1d7db881812d8512d67a69c9de1f18ca05f"}, + {file = "numpy-2.3.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:9d729d60f8d53a7361707f4b68a9663c968882dd4f09e0d58c044c8bf5faee7b"}, + {file = "numpy-2.3.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd0c630cf256b0a7fd9d0a11c9413b42fef5101219ce6ed5a09624f5a65392c7"}, + {file = "numpy-2.3.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5e081bc082825f8b139f9e9fe42942cb4054524598aaeb177ff476cc76d09d2"}, + {file = "numpy-2.3.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:15fb27364ed84114438fff8aaf998c9e19adbeba08c0b75409f8c452a8692c52"}, + {file = "numpy-2.3.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:85d9fb2d8cd998c84d13a79a09cc0c1091648e848e4e6249b0ccd7f6b487fa26"}, + {file = "numpy-2.3.4-cp314-cp314-win32.whl", hash = "sha256:e73d63fd04e3a9d6bc187f5455d81abfad05660b212c8804bf3b407e984cd2bc"}, + {file = "numpy-2.3.4-cp314-cp314-win_amd64.whl", hash = "sha256:3da3491cee49cf16157e70f607c03a217ea6647b1cea4819c4f48e53d49139b9"}, + {file = "numpy-2.3.4-cp314-cp314-win_arm64.whl", hash = "sha256:6d9cd732068e8288dbe2717177320723ccec4fb064123f0caf9bbd90ab5be868"}, + {file = "numpy-2.3.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:22758999b256b595cf0b1d102b133bb61866ba5ceecf15f759623b64c020c9ec"}, + {file = "numpy-2.3.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9cb177bc55b010b19798dc5497d540dea67fd13a8d9e882b2dae71de0cf09eb3"}, + {file = "numpy-2.3.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0f2bcc76f1e05e5ab58893407c63d90b2029908fa41f9f1cc51eecce936c3365"}, + {file = "numpy-2.3.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8dc20bde86802df2ed8397a08d793da0ad7a5fd4ea3ac85d757bf5dd4ad7c252"}, + {file = "numpy-2.3.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e199c087e2aa71c8f9ce1cb7a8e10677dc12457e7cc1be4798632da37c3e86e"}, + {file = "numpy-2.3.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85597b2d25ddf655495e2363fe044b0ae999b75bc4d630dc0d886484b03a5eb0"}, + {file = "numpy-2.3.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04a69abe45b49c5955923cf2c407843d1c85013b424ae8a560bba16c92fe44a0"}, + {file = "numpy-2.3.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e1708fac43ef8b419c975926ce1eaf793b0c13b7356cfab6ab0dc34c0a02ac0f"}, + {file = "numpy-2.3.4-cp314-cp314t-win32.whl", hash = "sha256:863e3b5f4d9915aaf1b8ec79ae560ad21f0b8d5e3adc31e73126491bb86dee1d"}, + {file = "numpy-2.3.4-cp314-cp314t-win_amd64.whl", hash = "sha256:962064de37b9aef801d33bc579690f8bfe6c5e70e29b61783f60bcba838a14d6"}, + {file = "numpy-2.3.4-cp314-cp314t-win_arm64.whl", hash = "sha256:8b5a9a39c45d852b62693d9b3f3e0fe052541f804296ff401a72a1b60edafb29"}, + {file = "numpy-2.3.4-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6e274603039f924c0fe5cb73438fa9246699c78a6df1bd3decef9ae592ae1c05"}, + {file = "numpy-2.3.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d149aee5c72176d9ddbc6803aef9c0f6d2ceeea7626574fc68518da5476fa346"}, + {file = "numpy-2.3.4-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:6d34ed9db9e6395bb6cd33286035f73a59b058169733a9db9f85e650b88df37e"}, + {file = "numpy-2.3.4-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:fdebe771ca06bb8d6abce84e51dca9f7921fe6ad34a0c914541b063e9a68928b"}, + {file = "numpy-2.3.4-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e92defe6c08211eb77902253b14fe5b480ebc5112bc741fd5e9cd0608f847"}, + {file = "numpy-2.3.4-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13b9062e4f5c7ee5c7e5be96f29ba71bc5a37fed3d1d77c37390ae00724d296d"}, + {file = "numpy-2.3.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:81b3a59793523e552c4a96109dde028aa4448ae06ccac5a76ff6532a85558a7f"}, + {file = "numpy-2.3.4.tar.gz", hash = "sha256:a7d018bfedb375a8d979ac758b120ba846a7fe764911a64465fd87b8729f4a6a"}, +] + [[package]] name = "overrides" version = "7.7.0" @@ -2037,7 +2586,7 @@ description = "A decorator to automatically detect mismatch when overriding a me optional = true python-versions = ">=3.6" groups = ["main"] -markers = "extra == \"dev\"" +markers = "extra == \"dev\" and python_version < \"3.12\"" files = [ {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, @@ -2071,15 +2620,15 @@ files = [ [[package]] name = "parso" -version = "0.8.4" +version = "0.8.5" description = "A Python Parser" optional = true python-versions = ">=3.6" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, - {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, + {file = "parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887"}, + {file = "parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a"}, ] [package.extras] @@ -2106,7 +2655,7 @@ description = "Pexpect allows easy control of interactive console applications." optional = true python-versions = "*" groups = ["main"] -markers = "extra == \"dev\" and sys_platform != \"win32\"" +markers = "extra == \"dev\" and sys_platform != \"win32\" and (python_version < \"3.14\" or sys_platform != \"win32\" and sys_platform != \"emscripten\")" files = [ {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, @@ -2122,7 +2671,7 @@ description = "Python Imaging Library (Fork)" optional = true python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"dev\" or extra == \"examples\"" +markers = "python_version < \"3.14\" and (extra == \"dev\" or extra == \"examples\")" files = [ {file = "pillow-11.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b9c17fd4ace828b3003dfd1e30bff24863e0eb59b535e8f80194d9cc7ecf860"}, {file = "pillow-11.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:65dc69160114cdd0ca0f35cb434633c75e8e7fad4cf855177a05bf38678f73ad"}, @@ -2241,17 +2790,127 @@ tests = ["check-manifest", "coverage (>=7.4.2)", "defusedxml", "markdown2", "ole typing = ["typing-extensions ; python_version < \"3.10\""] xmp = ["defusedxml"] +[[package]] +name = "pillow" +version = "12.0.0" +description = "Python Imaging Library (fork)" +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and (extra == \"dev\" or extra == \"examples\")" +files = [ + {file = "pillow-12.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:3adfb466bbc544b926d50fe8f4a4e6abd8c6bffd28a26177594e6e9b2b76572b"}, + {file = "pillow-12.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1ac11e8ea4f611c3c0147424eae514028b5e9077dd99ab91e1bd7bc33ff145e1"}, + {file = "pillow-12.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d49e2314c373f4c2b39446fb1a45ed333c850e09d0c59ac79b72eb3b95397363"}, + {file = "pillow-12.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c7b2a63fd6d5246349f3d3f37b14430d73ee7e8173154461785e43036ffa96ca"}, + {file = "pillow-12.0.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d64317d2587c70324b79861babb9c09f71fbb780bad212018874b2c013d8600e"}, + {file = "pillow-12.0.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d77153e14b709fd8b8af6f66a3afbb9ed6e9fc5ccf0b6b7e1ced7b036a228782"}, + {file = "pillow-12.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:32ed80ea8a90ee3e6fa08c21e2e091bba6eda8eccc83dbc34c95169507a91f10"}, + {file = "pillow-12.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c828a1ae702fc712978bda0320ba1b9893d99be0badf2647f693cc01cf0f04fa"}, + {file = "pillow-12.0.0-cp310-cp310-win32.whl", hash = "sha256:bd87e140e45399c818fac4247880b9ce719e4783d767e030a883a970be632275"}, + {file = "pillow-12.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:455247ac8a4cfb7b9bc45b7e432d10421aea9fc2e74d285ba4072688a74c2e9d"}, + {file = "pillow-12.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:6ace95230bfb7cd79ef66caa064bbe2f2a1e63d93471c3a2e1f1348d9f22d6b7"}, + {file = "pillow-12.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0fd00cac9c03256c8b2ff58f162ebcd2587ad3e1f2e397eab718c47e24d231cc"}, + {file = "pillow-12.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3475b96f5908b3b16c47533daaa87380c491357d197564e0ba34ae75c0f3257"}, + {file = "pillow-12.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:110486b79f2d112cf6add83b28b627e369219388f64ef2f960fef9ebaf54c642"}, + {file = "pillow-12.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5269cc1caeedb67e6f7269a42014f381f45e2e7cd42d834ede3c703a1d915fe3"}, + {file = "pillow-12.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa5129de4e174daccbc59d0a3b6d20eaf24417d59851c07ebb37aeb02947987c"}, + {file = "pillow-12.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bee2a6db3a7242ea309aa7ee8e2780726fed67ff4e5b40169f2c940e7eb09227"}, + {file = "pillow-12.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:90387104ee8400a7b4598253b4c406f8958f59fcf983a6cea2b50d59f7d63d0b"}, + {file = "pillow-12.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bc91a56697869546d1b8f0a3ff35224557ae7f881050e99f615e0119bf934b4e"}, + {file = "pillow-12.0.0-cp311-cp311-win32.whl", hash = "sha256:27f95b12453d165099c84f8a8bfdfd46b9e4bda9e0e4b65f0635430027f55739"}, + {file = "pillow-12.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:b583dc9070312190192631373c6c8ed277254aa6e6084b74bdd0a6d3b221608e"}, + {file = "pillow-12.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:759de84a33be3b178a64c8ba28ad5c135900359e85fb662bc6e403ad4407791d"}, + {file = "pillow-12.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:53561a4ddc36facb432fae7a9d8afbfaf94795414f5cdc5fc52f28c1dca90371"}, + {file = "pillow-12.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71db6b4c1653045dacc1585c1b0d184004f0d7e694c7b34ac165ca70c0838082"}, + {file = "pillow-12.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2fa5f0b6716fc88f11380b88b31fe591a06c6315e955c096c35715788b339e3f"}, + {file = "pillow-12.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82240051c6ca513c616f7f9da06e871f61bfd7805f566275841af15015b8f98d"}, + {file = "pillow-12.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55f818bd74fe2f11d4d7cbc65880a843c4075e0ac7226bc1a23261dbea531953"}, + {file = "pillow-12.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b87843e225e74576437fd5b6a4c2205d422754f84a06942cfaf1dc32243e45a8"}, + {file = "pillow-12.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c607c90ba67533e1b2355b821fef6764d1dd2cbe26b8c1005ae84f7aea25ff79"}, + {file = "pillow-12.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21f241bdd5080a15bc86d3466a9f6074a9c2c2b314100dd896ac81ee6db2f1ba"}, + {file = "pillow-12.0.0-cp312-cp312-win32.whl", hash = "sha256:dd333073e0cacdc3089525c7df7d39b211bcdf31fc2824e49d01c6b6187b07d0"}, + {file = "pillow-12.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe611163f6303d1619bbcb653540a4d60f9e55e622d60a3108be0d5b441017a"}, + {file = "pillow-12.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:7dfb439562f234f7d57b1ac6bc8fe7f838a4bd49c79230e0f6a1da93e82f1fad"}, + {file = "pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0869154a2d0546545cde61d1789a6524319fc1897d9ee31218eae7a60ccc5643"}, + {file = "pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a7921c5a6d31b3d756ec980f2f47c0cfdbce0fc48c22a39347a895f41f4a6ea4"}, + {file = "pillow-12.0.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1ee80a59f6ce048ae13cda1abf7fbd2a34ab9ee7d401c46be3ca685d1999a399"}, + {file = "pillow-12.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c50f36a62a22d350c96e49ad02d0da41dbd17ddc2e29750dbdba4323f85eb4a5"}, + {file = "pillow-12.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5193fde9a5f23c331ea26d0cf171fbf67e3f247585f50c08b3e205c7aeb4589b"}, + {file = "pillow-12.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bde737cff1a975b70652b62d626f7785e0480918dece11e8fef3c0cf057351c3"}, + {file = "pillow-12.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6597ff2b61d121172f5844b53f21467f7082f5fb385a9a29c01414463f93b07"}, + {file = "pillow-12.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b817e7035ea7f6b942c13aa03bb554fc44fea70838ea21f8eb31c638326584e"}, + {file = "pillow-12.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4f1231b7dec408e8670264ce63e9c71409d9583dd21d32c163e25213ee2a344"}, + {file = "pillow-12.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e51b71417049ad6ab14c49608b4a24d8fb3fe605e5dfabfe523b58064dc3d27"}, + {file = "pillow-12.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d120c38a42c234dc9a8c5de7ceaaf899cf33561956acb4941653f8bdc657aa79"}, + {file = "pillow-12.0.0-cp313-cp313-win32.whl", hash = "sha256:4cc6b3b2efff105c6a1656cfe59da4fdde2cda9af1c5e0b58529b24525d0a098"}, + {file = "pillow-12.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:4cf7fed4b4580601c4345ceb5d4cbf5a980d030fd5ad07c4d2ec589f95f09905"}, + {file = "pillow-12.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:9f0b04c6b8584c2c193babcccc908b38ed29524b29dd464bc8801bf10d746a3a"}, + {file = "pillow-12.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7fa22993bac7b77b78cae22bad1e2a987ddf0d9015c63358032f84a53f23cdc3"}, + {file = "pillow-12.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f135c702ac42262573fe9714dfe99c944b4ba307af5eb507abef1667e2cbbced"}, + {file = "pillow-12.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c85de1136429c524e55cfa4e033b4a7940ac5c8ee4d9401cc2d1bf48154bbc7b"}, + {file = "pillow-12.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38df9b4bfd3db902c9c2bd369bcacaf9d935b2fff73709429d95cc41554f7b3d"}, + {file = "pillow-12.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d87ef5795da03d742bf49439f9ca4d027cde49c82c5371ba52464aee266699a"}, + {file = "pillow-12.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aff9e4d82d082ff9513bdd6acd4f5bd359f5b2c870907d2b0a9c5e10d40c88fe"}, + {file = "pillow-12.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8d8ca2b210ada074d57fcee40c30446c9562e542fc46aedc19baf758a93532ee"}, + {file = "pillow-12.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:99a7f72fb6249302aa62245680754862a44179b545ded638cf1fef59befb57ef"}, + {file = "pillow-12.0.0-cp313-cp313t-win32.whl", hash = "sha256:4078242472387600b2ce8d93ade8899c12bf33fa89e55ec89fe126e9d6d5d9e9"}, + {file = "pillow-12.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2c54c1a783d6d60595d3514f0efe9b37c8808746a66920315bfd34a938d7994b"}, + {file = "pillow-12.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:26d9f7d2b604cd23aba3e9faf795787456ac25634d82cd060556998e39c6fa47"}, + {file = "pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:beeae3f27f62308f1ddbcfb0690bf44b10732f2ef43758f169d5e9303165d3f9"}, + {file = "pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d4827615da15cd59784ce39d3388275ec093ae3ee8d7f0c089b76fa87af756c2"}, + {file = "pillow-12.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:3e42edad50b6909089750e65c91aa09aaf1e0a71310d383f11321b27c224ed8a"}, + {file = "pillow-12.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e5d8efac84c9afcb40914ab49ba063d94f5dbdf5066db4482c66a992f47a3a3b"}, + {file = "pillow-12.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:266cd5f2b63ff316d5a1bba46268e603c9caf5606d44f38c2873c380950576ad"}, + {file = "pillow-12.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58eea5ebe51504057dd95c5b77d21700b77615ab0243d8152793dc00eb4faf01"}, + {file = "pillow-12.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f13711b1a5ba512d647a0e4ba79280d3a9a045aaf7e0cc6fbe96b91d4cdf6b0c"}, + {file = "pillow-12.0.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6846bd2d116ff42cba6b646edf5bf61d37e5cbd256425fa089fee4ff5c07a99e"}, + {file = "pillow-12.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c98fa880d695de164b4135a52fd2e9cd7b7c90a9d8ac5e9e443a24a95ef9248e"}, + {file = "pillow-12.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa3ed2a29a9e9d2d488b4da81dcb54720ac3104a20bf0bd273f1e4648aff5af9"}, + {file = "pillow-12.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d034140032870024e6b9892c692fe2968493790dd57208b2c37e3fb35f6df3ab"}, + {file = "pillow-12.0.0-cp314-cp314-win32.whl", hash = "sha256:1b1b133e6e16105f524a8dec491e0586d072948ce15c9b914e41cdadd209052b"}, + {file = "pillow-12.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:8dc232e39d409036af549c86f24aed8273a40ffa459981146829a324e0848b4b"}, + {file = "pillow-12.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:d52610d51e265a51518692045e372a4c363056130d922a7351429ac9f27e70b0"}, + {file = "pillow-12.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1979f4566bb96c1e50a62d9831e2ea2d1211761e5662afc545fa766f996632f6"}, + {file = "pillow-12.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b2e4b27a6e15b04832fe9bf292b94b5ca156016bbc1ea9c2c20098a0320d6cf6"}, + {file = "pillow-12.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fb3096c30df99fd01c7bf8e544f392103d0795b9f98ba71a8054bcbf56b255f1"}, + {file = "pillow-12.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7438839e9e053ef79f7112c881cef684013855016f928b168b81ed5835f3e75e"}, + {file = "pillow-12.0.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d5c411a8eaa2299322b647cd932586b1427367fd3184ffbb8f7a219ea2041ca"}, + {file = "pillow-12.0.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e091d464ac59d2c7ad8e7e08105eaf9dafbc3883fd7265ffccc2baad6ac925"}, + {file = "pillow-12.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:792a2c0be4dcc18af9d4a2dfd8a11a17d5e25274a1062b0ec1c2d79c76f3e7f8"}, + {file = "pillow-12.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:afbefa430092f71a9593a99ab6a4e7538bc9eabbf7bf94f91510d3503943edc4"}, + {file = "pillow-12.0.0-cp314-cp314t-win32.whl", hash = "sha256:3830c769decf88f1289680a59d4f4c46c72573446352e2befec9a8512104fa52"}, + {file = "pillow-12.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:905b0365b210c73afb0ebe9101a32572152dfd1c144c7e28968a331b9217b94a"}, + {file = "pillow-12.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:99353a06902c2e43b43e8ff74ee65a7d90307d82370604746738a1e0661ccca7"}, + {file = "pillow-12.0.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b22bd8c974942477156be55a768f7aa37c46904c175be4e158b6a86e3a6b7ca8"}, + {file = "pillow-12.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:805ebf596939e48dbb2e4922a1d3852cfc25c38160751ce02da93058b48d252a"}, + {file = "pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cae81479f77420d217def5f54b5b9d279804d17e982e0f2fa19b1d1e14ab5197"}, + {file = "pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeaefa96c768fc66818730b952a862235d68825c178f1b3ffd4efd7ad2edcb7c"}, + {file = "pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09f2d0abef9e4e2f349305a4f8cc784a8a6c2f58a8c4892eea13b10a943bd26e"}, + {file = "pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bdee52571a343d721fb2eb3b090a82d959ff37fc631e3f70422e0c2e029f3e76"}, + {file = "pillow-12.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b290fd8aa38422444d4b50d579de197557f182ef1068b75f5aa8558638b8d0a5"}, + {file = "pillow-12.0.0.tar.gz", hash = "sha256:87d4f8125c9988bfbed67af47dd7a953e2fc7b0cc1e7800ec6d2080d490bb353"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=8.2)", "sphinx-autobuild", "sphinx-copybutton", "sphinx-inline-tabs", "sphinxext-opengraph"] +fpx = ["olefile"] +mic = ["olefile"] +test-arrow = ["arro3-compute", "arro3-core", "nanoarrow", "pyarrow"] +tests = ["check-manifest", "coverage (>=7.4.2)", "defusedxml", "markdown2", "olefile", "packaging", "pyroma (>=5)", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "trove-classifiers (>=2024.10.12)"] +xmp = ["defusedxml"] + [[package]] name = "platformdirs" -version = "4.3.8" +version = "4.4.0" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." optional = true python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"dev\"" +markers = "python_version < \"3.14\" and extra == \"dev\"" files = [ - {file = "platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4"}, - {file = "platformdirs-4.3.8.tar.gz", hash = "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc"}, + {file = "platformdirs-4.4.0-py3-none-any.whl", hash = "sha256:abd01743f24e5287cd7a5db3752faf1a2d65353f38ec26d98e25a6db65958c85"}, + {file = "platformdirs-4.4.0.tar.gz", hash = "sha256:ca753cf4d81dc309bc67b0ea38fd15dc97bc30ce419a7f58d13eb3bf14c4febf"}, ] [package.extras] @@ -2259,6 +2918,24 @@ docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.1.3)", "sphinx-a test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.4)", "pytest-cov (>=6)", "pytest-mock (>=3.14)"] type = ["mypy (>=1.14.1)"] +[[package]] +name = "platformdirs" +version = "4.5.0" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and extra == \"dev\"" +files = [ + {file = "platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3"}, + {file = "platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312"}, +] + +[package.extras] +docs = ["furo (>=2025.9.25)", "proselint (>=0.14)", "sphinx (>=8.2.3)", "sphinx-autodoc-typehints (>=3.2)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.4.2)", "pytest-cov (>=7)", "pytest-mock (>=3.15.1)"] +type = ["mypy (>=1.18.2)"] + [[package]] name = "pluggy" version = "1.6.0" @@ -2315,15 +2992,15 @@ xlsxwriter = ["xlsxwriter"] [[package]] name = "prometheus-client" -version = "0.22.1" +version = "0.23.1" description = "Python client for the Prometheus monitoring system." optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "prometheus_client-0.22.1-py3-none-any.whl", hash = "sha256:cca895342e308174341b2cbf99a56bef291fbc0ef7b9e5412a0f26d653ba7094"}, - {file = "prometheus_client-0.22.1.tar.gz", hash = "sha256:190f1331e783cf21eb60bca559354e0a4d4378facecf78f5428c39b675d20d28"}, + {file = "prometheus_client-0.23.1-py3-none-any.whl", hash = "sha256:dd1913e6e76b59cfe44e7a4b83e01afc9873c1bdfd2ed8739f1e76aeca115f99"}, + {file = "prometheus_client-0.23.1.tar.gz", hash = "sha256:6ae8f9081eaaaf153a2e959d2e6c4f4fb57b12ef76c8c7980202f1e57b48b2ce"}, ] [package.extras] @@ -2331,15 +3008,15 @@ twisted = ["twisted"] [[package]] name = "prompt-toolkit" -version = "3.0.51" +version = "3.0.52" description = "Library for building powerful interactive command lines in Python" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "prompt_toolkit-3.0.51-py3-none-any.whl", hash = "sha256:52742911fde84e2d423e2f9a4cf1de7d7ac4e51958f648d9540e0fb8db077b07"}, - {file = "prompt_toolkit-3.0.51.tar.gz", hash = "sha256:931a162e3b27fc90c86f1b48bb1fb2c528c2761475e57c9c06de13311c7b54ed"}, + {file = "prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955"}, + {file = "prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855"}, ] [package.dependencies] @@ -2347,28 +3024,37 @@ wcwidth = "*" [[package]] name = "psutil" -version = "7.0.0" -description = "Cross-platform lib for process and system monitoring in Python. NOTE: the syntax of this script MUST be kept compatible with Python 2.7." +version = "7.1.2" +description = "Cross-platform lib for process and system monitoring." optional = true python-versions = ">=3.6" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25"}, - {file = "psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da"}, - {file = "psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91"}, - {file = "psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34"}, - {file = "psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993"}, - {file = "psutil-7.0.0-cp36-cp36m-win32.whl", hash = "sha256:84df4eb63e16849689f76b1ffcb36db7b8de703d1bc1fe41773db487621b6c17"}, - {file = "psutil-7.0.0-cp36-cp36m-win_amd64.whl", hash = "sha256:1e744154a6580bc968a0195fd25e80432d3afec619daf145b9e5ba16cc1d688e"}, - {file = "psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99"}, - {file = "psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553"}, - {file = "psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456"}, + {file = "psutil-7.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0cc5c6889b9871f231ed5455a9a02149e388fffcb30b607fb7a8896a6d95f22e"}, + {file = "psutil-7.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8e9e77a977208d84aa363a4a12e0f72189d58bbf4e46b49aae29a2c6e93ef206"}, + {file = "psutil-7.1.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d9623a5e4164d2220ecceb071f4b333b3c78866141e8887c072129185f41278"}, + {file = "psutil-7.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:364b1c10fe4ed59c89ec49e5f1a70da353b27986fa8233b4b999df4742a5ee2f"}, + {file = "psutil-7.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:f101ef84de7e05d41310e3ccbdd65a6dd1d9eed85e8aaf0758405d022308e204"}, + {file = "psutil-7.1.2-cp313-cp313t-win_arm64.whl", hash = "sha256:20c00824048a95de67f00afedc7b08b282aa08638585b0206a9fb51f28f1a165"}, + {file = "psutil-7.1.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:e09cfe92aa8e22b1ec5e2d394820cf86c5dff6367ac3242366485dfa874d43bc"}, + {file = "psutil-7.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fa6342cf859c48b19df3e4aa170e4cfb64aadc50b11e06bb569c6c777b089c9e"}, + {file = "psutil-7.1.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:625977443498ee7d6c1e63e93bacca893fd759a66c5f635d05e05811d23fb5ee"}, + {file = "psutil-7.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a24bcd7b7f2918d934af0fb91859f621b873d6aa81267575e3655cd387572a7"}, + {file = "psutil-7.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:329f05610da6380982e6078b9d0881d9ab1e9a7eb7c02d833bfb7340aa634e31"}, + {file = "psutil-7.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:7b04c29e3c0c888e83ed4762b70f31e65c42673ea956cefa8ced0e31e185f582"}, + {file = "psutil-7.1.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c9ba5c19f2d46203ee8c152c7b01df6eec87d883cfd8ee1af2ef2727f6b0f814"}, + {file = "psutil-7.1.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:2a486030d2fe81bec023f703d3d155f4823a10a47c36784c84f1cc7f8d39bedb"}, + {file = "psutil-7.1.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3efd8fc791492e7808a51cb2b94889db7578bfaea22df931424f874468e389e3"}, + {file = "psutil-7.1.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2aeb9b64f481b8eabfc633bd39e0016d4d8bbcd590d984af764d80bf0851b8a"}, + {file = "psutil-7.1.2-cp37-abi3-win_amd64.whl", hash = "sha256:8e17852114c4e7996fe9da4745c2bdef001ebbf2f260dec406290e66628bdb91"}, + {file = "psutil-7.1.2-cp37-abi3-win_arm64.whl", hash = "sha256:3e988455e61c240cc879cb62a008c2699231bf3e3d061d7fce4234463fd2abb4"}, + {file = "psutil-7.1.2.tar.gz", hash = "sha256:aa225cdde1335ff9684708ee8c72650f6598d5ed2114b9a7c5802030b1785018"}, ] [package.extras] -dev = ["abi3audit", "black (==24.10.0)", "check-manifest", "coverage", "packaging", "pylint", "pyperf", "pypinfo", "pytest", "pytest-cov", "pytest-xdist", "requests", "rstcheck", "ruff", "setuptools", "sphinx", "sphinx_rtd_theme", "toml-sort", "twine", "virtualenv", "vulture", "wheel"] -test = ["pytest", "pytest-xdist", "setuptools"] +dev = ["abi3audit", "black", "check-manifest", "coverage", "packaging", "pylint", "pyperf", "pypinfo", "pyreadline ; os_name == \"nt\"", "pytest", "pytest-cov", "pytest-instafail", "pytest-subtests", "pytest-xdist", "pywin32 ; os_name == \"nt\" and platform_python_implementation != \"PyPy\"", "requests", "rstcheck", "ruff", "setuptools", "sphinx", "sphinx_rtd_theme", "toml-sort", "twine", "validate-pyproject[all]", "virtualenv", "vulture", "wheel", "wheel ; os_name == \"nt\" and platform_python_implementation != \"PyPy\"", "wmi ; os_name == \"nt\" and platform_python_implementation != \"PyPy\""] +test = ["pytest", "pytest-instafail", "pytest-subtests", "pytest-xdist", "pywin32 ; os_name == \"nt\" and platform_python_implementation != \"PyPy\"", "setuptools", "wheel ; os_name == \"nt\" and platform_python_implementation != \"PyPy\"", "wmi ; os_name == \"nt\" and platform_python_implementation != \"PyPy\""] [[package]] name = "ptyprocess" @@ -2377,7 +3063,7 @@ description = "Run a subprocess in a pseudo terminal" optional = true python-versions = "*" groups = ["main"] -markers = "extra == \"dev\" and (sys_platform != \"win32\" or os_name != \"nt\")" +markers = "extra == \"dev\" and (sys_platform != \"win32\" or os_name != \"nt\") and (python_version < \"3.14\" or sys_platform != \"win32\" and sys_platform != \"emscripten\" or os_name != \"nt\")" files = [ {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, @@ -2401,15 +3087,15 @@ tests = ["pytest"] [[package]] name = "pycparser" -version = "2.22" +version = "2.23" description = "C parser in Python" optional = true python-versions = ">=3.8" groups = ["main"] -markers = "extra == \"dev\"" +markers = "extra == \"dev\" and implementation_name != \"PyPy\"" files = [ - {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, - {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, + {file = "pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934"}, + {file = "pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2"}, ] [[package]] @@ -2430,15 +3116,15 @@ windows-terminal = ["colorama (>=0.4.6)"] [[package]] name = "pyparsing" -version = "3.2.3" -description = "pyparsing module - Classes and methods to define and execute parsing grammars" +version = "3.2.5" +description = "pyparsing - Classes and methods to define and execute parsing grammars" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\" or extra == \"examples\"" files = [ - {file = "pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf"}, - {file = "pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be"}, + {file = "pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e"}, + {file = "pyparsing-3.2.5.tar.gz", hash = "sha256:2df8d5b7b2802ef88e8d016a2eb9c7aeaa923529cd251ed0fe4608275d4105b6"}, ] [package.extras] @@ -2486,15 +3172,15 @@ six = ">=1.5" [[package]] name = "python-json-logger" -version = "3.3.0" +version = "4.0.0" description = "JSON Log Formatter for the Python Logging Package" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "python_json_logger-3.3.0-py3-none-any.whl", hash = "sha256:dd980fae8cffb24c13caf6e158d3d61c0d6d22342f932cb6e9deedab3d35eec7"}, - {file = "python_json_logger-3.3.0.tar.gz", hash = "sha256:12b7e74b17775e7d565129296105bbe3910842d9d0eb083fc83a6a617aa8df84"}, + {file = "python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2"}, + {file = "python_json_logger-4.0.0.tar.gz", hash = "sha256:f58e68eb46e1faed27e0f574a55a0455eecd7b8a5b88b85a784519ba3cff047f"}, ] [package.dependencies] @@ -2510,7 +3196,7 @@ description = "Python for Window Extensions" optional = true python-versions = "*" groups = ["main"] -markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\" and extra == \"dev\"" +markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\" and extra == \"dev\" and python_version < \"3.14\"" files = [ {file = "pywin32-311-cp310-cp310-win32.whl", hash = "sha256:d03ff496d2a0cd4a5893504789d4a15399133fe82517455e78bad62efbb7f0a3"}, {file = "pywin32-311-cp310-cp310-win_amd64.whl", hash = "sha256:797c2772017851984b97180b0bebe4b620bb86328e8a884bb626156295a63b3b"}, @@ -2536,173 +3222,208 @@ files = [ [[package]] name = "pywinpty" -version = "2.0.15" +version = "3.0.2" description = "Pseudo terminal support for Windows from Python." optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\" and os_name == \"nt\"" files = [ - {file = "pywinpty-2.0.15-cp310-cp310-win_amd64.whl", hash = "sha256:8e7f5de756a615a38b96cd86fa3cd65f901ce54ce147a3179c45907fa11b4c4e"}, - {file = "pywinpty-2.0.15-cp311-cp311-win_amd64.whl", hash = "sha256:9a6bcec2df2707aaa9d08b86071970ee32c5026e10bcc3cc5f6f391d85baf7ca"}, - {file = "pywinpty-2.0.15-cp312-cp312-win_amd64.whl", hash = "sha256:83a8f20b430bbc5d8957249f875341a60219a4e971580f2ba694fbfb54a45ebc"}, - {file = "pywinpty-2.0.15-cp313-cp313-win_amd64.whl", hash = "sha256:ab5920877dd632c124b4ed17bc6dd6ef3b9f86cd492b963ffdb1a67b85b0f408"}, - {file = "pywinpty-2.0.15-cp313-cp313t-win_amd64.whl", hash = "sha256:a4560ad8c01e537708d2790dbe7da7d986791de805d89dd0d3697ca59e9e4901"}, - {file = "pywinpty-2.0.15-cp39-cp39-win_amd64.whl", hash = "sha256:d261cd88fcd358cfb48a7ca0700db3e1c088c9c10403c9ebc0d8a8b57aa6a117"}, - {file = "pywinpty-2.0.15.tar.gz", hash = "sha256:312cf39153a8736c617d45ce8b6ad6cd2107de121df91c455b10ce6bba7a39b2"}, + {file = "pywinpty-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:65db57fd3387d71e8372b6a54269cbcd0f6dfa6d4616a29e0af749ec19f5c558"}, + {file = "pywinpty-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:327790d70e4c841ebd9d0f295a780177149aeb405bca44c7115a3de5c2054b23"}, + {file = "pywinpty-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:99fdd9b455f0ad6419aba6731a7a0d2f88ced83c3c94a80ff9533d95fa8d8a9e"}, + {file = "pywinpty-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:18f78b81e4cfee6aabe7ea8688441d30247b73e52cd9657138015c5f4ee13a51"}, + {file = "pywinpty-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:663383ecfab7fc382cc97ea5c4f7f0bb32c2f889259855df6ea34e5df42d305b"}, + {file = "pywinpty-3.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:28297cecc37bee9f24d8889e47231972d6e9e84f7b668909de54f36ca785029a"}, + {file = "pywinpty-3.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:34b55ae9a1b671fe3eae071d86618110538e8eaad18fcb1531c0830b91a82767"}, + {file = "pywinpty-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:3962daf801bc38dd4de872108c424b5338c9a46c6efca5761854cd66370a9022"}, + {file = "pywinpty-3.0.2.tar.gz", hash = "sha256:1505cc4cb248af42cb6285a65c9c2086ee9e7e574078ee60933d5d7fa86fb004"}, ] [[package]] name = "pyyaml" -version = "6.0.2" +version = "6.0.3" description = "YAML parser and emitter for Python" optional = false python-versions = ">=3.8" groups = ["main"] files = [ - {file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"}, - {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"}, - {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237"}, - {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b"}, - {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed"}, - {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180"}, - {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68"}, - {file = "PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99"}, - {file = "PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e"}, - {file = "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774"}, - {file = "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee"}, - {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c"}, - {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317"}, - {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85"}, - {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4"}, - {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e"}, - {file = "PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5"}, - {file = "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"}, - {file = "PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab"}, - {file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"}, - {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48"}, - {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b"}, - {file = "PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4"}, - {file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"}, - {file = "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba"}, - {file = "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1"}, - {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133"}, - {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484"}, - {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5"}, - {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc"}, - {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652"}, - {file = "PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183"}, - {file = "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563"}, - {file = "PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a"}, - {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5"}, - {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d"}, - {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083"}, - {file = "PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706"}, - {file = "PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a"}, - {file = "PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff"}, - {file = "PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d"}, - {file = "PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f"}, - {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290"}, - {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12"}, - {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19"}, - {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e"}, - {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725"}, - {file = "PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631"}, - {file = "PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8"}, - {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, + {file = "PyYAML-6.0.3-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:c2514fceb77bc5e7a2f7adfaa1feb2fb311607c9cb518dbc378688ec73d8292f"}, + {file = "PyYAML-6.0.3-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c57bb8c96f6d1808c030b1687b9b5fb476abaa47f0db9c0101f5e9f394e97f4"}, + {file = "PyYAML-6.0.3-cp38-cp38-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efd7b85f94a6f21e4932043973a7ba2613b059c4a000551892ac9f1d11f5baf3"}, + {file = "PyYAML-6.0.3-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22ba7cfcad58ef3ecddc7ed1db3409af68d023b7f940da23c6c2a1890976eda6"}, + {file = "PyYAML-6.0.3-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:6344df0d5755a2c9a276d4473ae6b90647e216ab4757f8426893b5dd2ac3f369"}, + {file = "PyYAML-6.0.3-cp38-cp38-win32.whl", hash = "sha256:3ff07ec89bae51176c0549bc4c63aa6202991da2d9a6129d7aef7f1407d3f295"}, + {file = "PyYAML-6.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:5cf4e27da7e3fbed4d6c3d8e797387aaad68102272f8f9752883bc32d61cb87b"}, + {file = "pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b"}, + {file = "pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956"}, + {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8"}, + {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198"}, + {file = "pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b"}, + {file = "pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0"}, + {file = "pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69"}, + {file = "pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e"}, + {file = "pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c"}, + {file = "pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e"}, + {file = "pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824"}, + {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c"}, + {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00"}, + {file = "pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d"}, + {file = "pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a"}, + {file = "pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4"}, + {file = "pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b"}, + {file = "pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf"}, + {file = "pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196"}, + {file = "pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0"}, + {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28"}, + {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c"}, + {file = "pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc"}, + {file = "pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e"}, + {file = "pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea"}, + {file = "pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5"}, + {file = "pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b"}, + {file = "pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd"}, + {file = "pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8"}, + {file = "pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1"}, + {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c"}, + {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5"}, + {file = "pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6"}, + {file = "pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6"}, + {file = "pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be"}, + {file = "pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26"}, + {file = "pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c"}, + {file = "pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb"}, + {file = "pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac"}, + {file = "pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310"}, + {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7"}, + {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788"}, + {file = "pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5"}, + {file = "pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764"}, + {file = "pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35"}, + {file = "pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac"}, + {file = "pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3"}, + {file = "pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3"}, + {file = "pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba"}, + {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c"}, + {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702"}, + {file = "pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c"}, + {file = "pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065"}, + {file = "pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65"}, + {file = "pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9"}, + {file = "pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b"}, + {file = "pyyaml-6.0.3-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:b865addae83924361678b652338317d1bd7e79b1f4596f96b96c77a5a34b34da"}, + {file = "pyyaml-6.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c3355370a2c156cffb25e876646f149d5d68f5e0a3ce86a5084dd0b64a994917"}, + {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c5677e12444c15717b902a5798264fa7909e41153cdf9ef7ad571b704a63dd9"}, + {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5ed875a24292240029e4483f9d4a4b8a1ae08843b9c54f43fcc11e404532a8a5"}, + {file = "pyyaml-6.0.3-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0150219816b6a1fa26fb4699fb7daa9caf09eb1999f3b70fb6e786805e80375a"}, + {file = "pyyaml-6.0.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:fa160448684b4e94d80416c0fa4aac48967a969efe22931448d853ada8baf926"}, + {file = "pyyaml-6.0.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:27c0abcb4a5dac13684a37f76e701e054692a9b2d3064b70f5e4eb54810553d7"}, + {file = "pyyaml-6.0.3-cp39-cp39-win32.whl", hash = "sha256:1ebe39cb5fc479422b83de611d14e2c0d3bb2a18bbcb01f229ab3cfbd8fee7a0"}, + {file = "pyyaml-6.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:2e71d11abed7344e42a8849600193d15b6def118602c4c176f748e4583246007"}, + {file = "pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f"}, ] [[package]] name = "pyzmq" -version = "27.0.0" +version = "27.1.0" description = "Python bindings for 0MQ" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "pyzmq-27.0.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:b973ee650e8f442ce482c1d99ca7ab537c69098d53a3d046676a484fd710c87a"}, - {file = "pyzmq-27.0.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:661942bc7cd0223d569d808f2e5696d9cc120acc73bf3e88a1f1be7ab648a7e4"}, - {file = "pyzmq-27.0.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50360fb2a056ffd16e5f4177eee67f1dd1017332ea53fb095fe7b5bf29c70246"}, - {file = "pyzmq-27.0.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf209a6dc4b420ed32a7093642843cbf8703ed0a7d86c16c0b98af46762ebefb"}, - {file = "pyzmq-27.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c2dace4a7041cca2fba5357a2d7c97c5effdf52f63a1ef252cfa496875a3762d"}, - {file = "pyzmq-27.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:63af72b2955fc77caf0a77444baa2431fcabb4370219da38e1a9f8d12aaebe28"}, - {file = "pyzmq-27.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e8c4adce8e37e75c4215297d7745551b8dcfa5f728f23ce09bf4e678a9399413"}, - {file = "pyzmq-27.0.0-cp310-cp310-win32.whl", hash = "sha256:5d5ef4718ecab24f785794e0e7536436698b459bfbc19a1650ef55280119d93b"}, - {file = "pyzmq-27.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:e40609380480b3d12c30f841323f42451c755b8fece84235236f5fe5ffca8c1c"}, - {file = "pyzmq-27.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:6b0397b0be277b46762956f576e04dc06ced265759e8c2ff41a0ee1aa0064198"}, - {file = "pyzmq-27.0.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:21457825249b2a53834fa969c69713f8b5a79583689387a5e7aed880963ac564"}, - {file = "pyzmq-27.0.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1958947983fef513e6e98eff9cb487b60bf14f588dc0e6bf35fa13751d2c8251"}, - {file = "pyzmq-27.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0dc628b5493f9a8cd9844b8bee9732ef587ab00002157c9329e4fc0ef4d3afa"}, - {file = "pyzmq-27.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7bbe9e1ed2c8d3da736a15694d87c12493e54cc9dc9790796f0321794bbc91f"}, - {file = "pyzmq-27.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dc1091f59143b471d19eb64f54bae4f54bcf2a466ffb66fe45d94d8d734eb495"}, - {file = "pyzmq-27.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7011ade88c8e535cf140f8d1a59428676fbbce7c6e54fefce58bf117aefb6667"}, - {file = "pyzmq-27.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:2c386339d7e3f064213aede5d03d054b237937fbca6dd2197ac8cf3b25a6b14e"}, - {file = "pyzmq-27.0.0-cp311-cp311-win32.whl", hash = "sha256:0546a720c1f407b2172cb04b6b094a78773491497e3644863cf5c96c42df8cff"}, - {file = "pyzmq-27.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:15f39d50bd6c9091c67315ceb878a4f531957b121d2a05ebd077eb35ddc5efed"}, - {file = "pyzmq-27.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c5817641eebb391a2268c27fecd4162448e03538387093cdbd8bf3510c316b38"}, - {file = "pyzmq-27.0.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:cbabc59dcfaac66655c040dfcb8118f133fb5dde185e5fc152628354c1598e52"}, - {file = "pyzmq-27.0.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:cb0ac5179cba4b2f94f1aa208fbb77b62c4c9bf24dd446278b8b602cf85fcda3"}, - {file = "pyzmq-27.0.0-cp312-abi3-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53a48f0228eab6cbf69fde3aa3c03cbe04e50e623ef92ae395fce47ef8a76152"}, - {file = "pyzmq-27.0.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:111db5f395e09f7e775f759d598f43cb815fc58e0147623c4816486e1a39dc22"}, - {file = "pyzmq-27.0.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c8878011653dcdc27cc2c57e04ff96f0471e797f5c19ac3d7813a245bcb24371"}, - {file = "pyzmq-27.0.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:c0ed2c1f335ba55b5fdc964622254917d6b782311c50e138863eda409fbb3b6d"}, - {file = "pyzmq-27.0.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e918d70862d4cfd4b1c187310015646a14e1f5917922ab45b29f28f345eeb6be"}, - {file = "pyzmq-27.0.0-cp312-abi3-win32.whl", hash = "sha256:88b4e43cab04c3c0f0d55df3b1eef62df2b629a1a369b5289a58f6fa8b07c4f4"}, - {file = "pyzmq-27.0.0-cp312-abi3-win_amd64.whl", hash = "sha256:dce4199bf5f648a902ce37e7b3afa286f305cd2ef7a8b6ec907470ccb6c8b371"}, - {file = "pyzmq-27.0.0-cp312-abi3-win_arm64.whl", hash = "sha256:56e46bbb85d52c1072b3f809cc1ce77251d560bc036d3a312b96db1afe76db2e"}, - {file = "pyzmq-27.0.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:c36ad534c0c29b4afa088dc53543c525b23c0797e01b69fef59b1a9c0e38b688"}, - {file = "pyzmq-27.0.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:67855c14173aec36395d7777aaba3cc527b393821f30143fd20b98e1ff31fd38"}, - {file = "pyzmq-27.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8617c7d43cd8ccdb62aebe984bfed77ca8f036e6c3e46dd3dddda64b10f0ab7a"}, - {file = "pyzmq-27.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:67bfbcbd0a04c575e8103a6061d03e393d9f80ffdb9beb3189261e9e9bc5d5e9"}, - {file = "pyzmq-27.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5cd11d46d7b7e5958121b3eaf4cd8638eff3a720ec527692132f05a57f14341d"}, - {file = "pyzmq-27.0.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:b801c2e40c5aa6072c2f4876de8dccd100af6d9918d4d0d7aa54a1d982fd4f44"}, - {file = "pyzmq-27.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:20d5cb29e8c5f76a127c75b6e7a77e846bc4b655c373baa098c26a61b7ecd0ef"}, - {file = "pyzmq-27.0.0-cp313-cp313t-win32.whl", hash = "sha256:a20528da85c7ac7a19b7384e8c3f8fa707841fd85afc4ed56eda59d93e3d98ad"}, - {file = "pyzmq-27.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:d8229f2efece6a660ee211d74d91dbc2a76b95544d46c74c615e491900dc107f"}, - {file = "pyzmq-27.0.0-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:f4162dbbd9c5c84fb930a36f290b08c93e35fce020d768a16fc8891a2f72bab8"}, - {file = "pyzmq-27.0.0-cp38-cp38-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4e7d0a8d460fba526cc047333bdcbf172a159b8bd6be8c3eb63a416ff9ba1477"}, - {file = "pyzmq-27.0.0-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:29f44e3c26b9783816ba9ce274110435d8f5b19bbd82f7a6c7612bb1452a3597"}, - {file = "pyzmq-27.0.0-cp38-cp38-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e435540fa1da54667f0026cf1e8407fe6d8a11f1010b7f06b0b17214ebfcf5e"}, - {file = "pyzmq-27.0.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:51f5726de3532b8222e569990c8aa34664faa97038304644679a51d906e60c6e"}, - {file = "pyzmq-27.0.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:42c7555123679637c99205b1aa9e8f7d90fe29d4c243c719e347d4852545216c"}, - {file = "pyzmq-27.0.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:a979b7cf9e33d86c4949df527a3018767e5f53bc3b02adf14d4d8db1db63ccc0"}, - {file = "pyzmq-27.0.0-cp38-cp38-win32.whl", hash = "sha256:26b72c5ae20bf59061c3570db835edb81d1e0706ff141747055591c4b41193f8"}, - {file = "pyzmq-27.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:55a0155b148fe0428285a30922f7213539aa84329a5ad828bca4bbbc665c70a4"}, - {file = "pyzmq-27.0.0-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:100f6e5052ba42b2533011d34a018a5ace34f8cac67cb03cfa37c8bdae0ca617"}, - {file = "pyzmq-27.0.0-cp39-cp39-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:bf6c6b061efd00404b9750e2cfbd9507492c8d4b3721ded76cb03786131be2ed"}, - {file = "pyzmq-27.0.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee05728c0b0b2484a9fc20466fa776fffb65d95f7317a3419985b8c908563861"}, - {file = "pyzmq-27.0.0-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7cdf07fe0a557b131366f80727ec8ccc4b70d89f1e3f920d94a594d598d754f0"}, - {file = "pyzmq-27.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:90252fa2ff3a104219db1f5ced7032a7b5fc82d7c8d2fec2b9a3e6fd4e25576b"}, - {file = "pyzmq-27.0.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:ea6d441c513bf18c578c73c323acf7b4184507fc244762193aa3a871333c9045"}, - {file = "pyzmq-27.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:ae2b34bcfaae20c064948a4113bf8709eee89fd08317eb293ae4ebd69b4d9740"}, - {file = "pyzmq-27.0.0-cp39-cp39-win32.whl", hash = "sha256:5b10bd6f008937705cf6e7bf8b6ece5ca055991e3eb130bca8023e20b86aa9a3"}, - {file = "pyzmq-27.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:00387d12a8af4b24883895f7e6b9495dc20a66027b696536edac35cb988c38f3"}, - {file = "pyzmq-27.0.0-cp39-cp39-win_arm64.whl", hash = "sha256:4c19d39c04c29a6619adfeb19e3735c421b3bfee082f320662f52e59c47202ba"}, - {file = "pyzmq-27.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:656c1866505a5735d0660b7da6d7147174bbf59d4975fc2b7f09f43c9bc25745"}, - {file = "pyzmq-27.0.0-pp310-pypy310_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:74175b9e12779382432dd1d1f5960ebe7465d36649b98a06c6b26be24d173fab"}, - {file = "pyzmq-27.0.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8c6de908465697a8708e4d6843a1e884f567962fc61eb1706856545141d0cbb"}, - {file = "pyzmq-27.0.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c644aaacc01d0df5c7072826df45e67301f191c55f68d7b2916d83a9ddc1b551"}, - {file = "pyzmq-27.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:10f70c1d9a446a85013a36871a296007f6fe4232b530aa254baf9da3f8328bc0"}, - {file = "pyzmq-27.0.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd1dc59763effd1576f8368047c9c31468fce0af89d76b5067641137506792ae"}, - {file = "pyzmq-27.0.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:60e8cc82d968174650c1860d7b716366caab9973787a1c060cf8043130f7d0f7"}, - {file = "pyzmq-27.0.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14fe7aaac86e4e93ea779a821967360c781d7ac5115b3f1a171ced77065a0174"}, - {file = "pyzmq-27.0.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6ad0562d4e6abb785be3e4dd68599c41be821b521da38c402bc9ab2a8e7ebc7e"}, - {file = "pyzmq-27.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:9df43a2459cd3a3563404c1456b2c4c69564daa7dbaf15724c09821a3329ce46"}, - {file = "pyzmq-27.0.0-pp38-pypy38_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8c86ea8fe85e2eb0ffa00b53192c401477d5252f6dd1db2e2ed21c1c30d17e5e"}, - {file = "pyzmq-27.0.0-pp38-pypy38_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:c45fee3968834cd291a13da5fac128b696c9592a9493a0f7ce0b47fa03cc574d"}, - {file = "pyzmq-27.0.0-pp38-pypy38_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cae73bb6898c4e045fbed5024cb587e4110fddb66f6163bcab5f81f9d4b9c496"}, - {file = "pyzmq-27.0.0-pp38-pypy38_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:26d542258c7a1f35a9cff3d887687d3235006134b0ac1c62a6fe1ad3ac10440e"}, - {file = "pyzmq-27.0.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:04cd50ef3b28e35ced65740fb9956a5b3f77a6ff32fcd887e3210433f437dd0f"}, - {file = "pyzmq-27.0.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:39ddd3ba0a641f01d8f13a3cfd4c4924eb58e660d8afe87e9061d6e8ca6f7ac3"}, - {file = "pyzmq-27.0.0-pp39-pypy39_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:8ca7e6a0388dd9e1180b14728051068f4efe83e0d2de058b5ff92c63f399a73f"}, - {file = "pyzmq-27.0.0-pp39-pypy39_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2524c40891be6a3106885a3935d58452dd83eb7a5742a33cc780a1ad4c49dec0"}, - {file = "pyzmq-27.0.0-pp39-pypy39_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a56e3e5bd2d62a01744fd2f1ce21d760c7c65f030e9522738d75932a14ab62a"}, - {file = "pyzmq-27.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:096af9e133fec3a72108ddefba1e42985cb3639e9de52cfd336b6fc23aa083e9"}, - {file = "pyzmq-27.0.0.tar.gz", hash = "sha256:b1f08eeb9ce1510e6939b6e5dcd46a17765e2333daae78ecf4606808442e52cf"}, + {file = "pyzmq-27.1.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:508e23ec9bc44c0005c4946ea013d9317ae00ac67778bd47519fdf5a0e930ff4"}, + {file = "pyzmq-27.1.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:507b6f430bdcf0ee48c0d30e734ea89ce5567fd7b8a0f0044a369c176aa44556"}, + {file = "pyzmq-27.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf7b38f9fd7b81cb6d9391b2946382c8237fd814075c6aa9c3b746d53076023b"}, + {file = "pyzmq-27.1.0-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03ff0b279b40d687691a6217c12242ee71f0fba28bf8626ff50e3ef0f4410e1e"}, + {file = "pyzmq-27.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:677e744fee605753eac48198b15a2124016c009a11056f93807000ab11ce6526"}, + {file = "pyzmq-27.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd2fec2b13137416a1c5648b7009499bcc8fea78154cd888855fa32514f3dad1"}, + {file = "pyzmq-27.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:08e90bb4b57603b84eab1d0ca05b3bbb10f60c1839dc471fc1c9e1507bef3386"}, + {file = "pyzmq-27.1.0-cp310-cp310-win32.whl", hash = "sha256:a5b42d7a0658b515319148875fcb782bbf118dd41c671b62dae33666c2213bda"}, + {file = "pyzmq-27.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:c0bb87227430ee3aefcc0ade2088100e528d5d3298a0a715a64f3d04c60ba02f"}, + {file = "pyzmq-27.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:9a916f76c2ab8d045b19f2286851a38e9ac94ea91faf65bd64735924522a8b32"}, + {file = "pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86"}, + {file = "pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581"}, + {file = "pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f"}, + {file = "pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e"}, + {file = "pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e"}, + {file = "pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2"}, + {file = "pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394"}, + {file = "pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f"}, + {file = "pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97"}, + {file = "pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07"}, + {file = "pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc"}, + {file = "pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113"}, + {file = "pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233"}, + {file = "pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31"}, + {file = "pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28"}, + {file = "pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856"}, + {file = "pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496"}, + {file = "pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd"}, + {file = "pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf"}, + {file = "pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f"}, + {file = "pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5"}, + {file = "pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6"}, + {file = "pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7"}, + {file = "pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05"}, + {file = "pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9"}, + {file = "pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128"}, + {file = "pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39"}, + {file = "pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97"}, + {file = "pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db"}, + {file = "pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c"}, + {file = "pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2"}, + {file = "pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e"}, + {file = "pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a"}, + {file = "pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea"}, + {file = "pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96"}, + {file = "pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d"}, + {file = "pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146"}, + {file = "pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd"}, + {file = "pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a"}, + {file = "pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92"}, + {file = "pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0"}, + {file = "pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7"}, + {file = "pyzmq-27.1.0-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:18339186c0ed0ce5835f2656cdfb32203125917711af64da64dbaa3d949e5a1b"}, + {file = "pyzmq-27.1.0-cp38-cp38-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:753d56fba8f70962cd8295fb3edb40b9b16deaa882dd2b5a3a2039f9ff7625aa"}, + {file = "pyzmq-27.1.0-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b721c05d932e5ad9ff9344f708c96b9e1a485418c6618d765fca95d4daacfbef"}, + {file = "pyzmq-27.1.0-cp38-cp38-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be883ff3d722e6085ee3f4afc057a50f7f2e0c72d289fd54df5706b4e3d3a50"}, + {file = "pyzmq-27.1.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:b2e592db3a93128daf567de9650a2f3859017b3f7a66bc4ed6e4779d6034976f"}, + {file = "pyzmq-27.1.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:ad68808a61cbfbbae7ba26d6233f2a4aa3b221de379ce9ee468aa7a83b9c36b0"}, + {file = "pyzmq-27.1.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:e2687c2d230e8d8584fbea433c24382edfeda0c60627aca3446aa5e58d5d1831"}, + {file = "pyzmq-27.1.0-cp38-cp38-win32.whl", hash = "sha256:a1aa0ee920fb3825d6c825ae3f6c508403b905b698b6460408ebd5bb04bbb312"}, + {file = "pyzmq-27.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:df7cd397ece96cf20a76fae705d40efbab217d217897a5053267cd88a700c266"}, + {file = "pyzmq-27.1.0-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:96c71c32fff75957db6ae33cd961439f386505c6e6b377370af9b24a1ef9eafb"}, + {file = "pyzmq-27.1.0-cp39-cp39-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:49d3980544447f6bd2968b6ac913ab963a49dcaa2d4a2990041f16057b04c429"}, + {file = "pyzmq-27.1.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:849ca054d81aa1c175c49484afaaa5db0622092b5eccb2055f9f3bb8f703782d"}, + {file = "pyzmq-27.1.0-cp39-cp39-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3970778e74cb7f85934d2b926b9900e92bfe597e62267d7499acc39c9c28e345"}, + {file = "pyzmq-27.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:da96ecdcf7d3919c3be2de91a8c513c186f6762aa6cf7c01087ed74fad7f0968"}, + {file = "pyzmq-27.1.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:9541c444cfe1b1c0156c5c86ece2bb926c7079a18e7b47b0b1b3b1b875e5d098"}, + {file = "pyzmq-27.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:e30a74a39b93e2e1591b58eb1acef4902be27c957a8720b0e368f579b82dc22f"}, + {file = "pyzmq-27.1.0-cp39-cp39-win32.whl", hash = "sha256:b1267823d72d1e40701dcba7edc45fd17f71be1285557b7fe668887150a14b78"}, + {file = "pyzmq-27.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:0c996ded912812a2fcd7ab6574f4ad3edc27cb6510349431e4930d4196ade7db"}, + {file = "pyzmq-27.1.0-cp39-cp39-win_arm64.whl", hash = "sha256:346e9ba4198177a07e7706050f35d733e08c1c1f8ceacd5eb6389d653579ffbc"}, + {file = "pyzmq-27.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c17e03cbc9312bee223864f1a2b13a99522e0dc9f7c5df0177cd45210ac286e6"}, + {file = "pyzmq-27.1.0-pp310-pypy310_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f328d01128373cb6763823b2b4e7f73bdf767834268c565151eacb3b7a392f90"}, + {file = "pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c1790386614232e1b3a40a958454bdd42c6d1811837b15ddbb052a032a43f62"}, + {file = "pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:448f9cb54eb0cee4732b46584f2710c8bc178b0e5371d9e4fc8125201e413a74"}, + {file = "pyzmq-27.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:05b12f2d32112bf8c95ef2e74ec4f1d4beb01f8b5e703b38537f8849f92cb9ba"}, + {file = "pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066"}, + {file = "pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604"}, + {file = "pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c"}, + {file = "pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271"}, + {file = "pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355"}, + {file = "pyzmq-27.1.0-pp38-pypy38_pp73-macosx_10_15_x86_64.whl", hash = "sha256:50081a4e98472ba9f5a02850014b4c9b629da6710f8f14f3b15897c666a28f1b"}, + {file = "pyzmq-27.1.0-pp38-pypy38_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:510869f9df36ab97f89f4cff9d002a89ac554c7ac9cadd87d444aa4cf66abd27"}, + {file = "pyzmq-27.1.0-pp38-pypy38_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1f8426a01b1c4098a750973c37131cf585f61c7911d735f729935a0c701b68d3"}, + {file = "pyzmq-27.1.0-pp38-pypy38_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:726b6a502f2e34c6d2ada5e702929586d3ac948a4dbbb7fed9854ec8c0466027"}, + {file = "pyzmq-27.1.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:bd67e7c8f4654bef471c0b1ca6614af0b5202a790723a58b79d9584dc8022a78"}, + {file = "pyzmq-27.1.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:722ea791aa233ac0a819fc2c475e1292c76930b31f1d828cb61073e2fe5e208f"}, + {file = "pyzmq-27.1.0-pp39-pypy39_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:01f9437501886d3a1dd4b02ef59fb8cc384fa718ce066d52f175ee49dd5b7ed8"}, + {file = "pyzmq-27.1.0-pp39-pypy39_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4a19387a3dddcc762bfd2f570d14e2395b2c9701329b266f83dd87a2b3cbd381"}, + {file = "pyzmq-27.1.0-pp39-pypy39_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c618fbcd069e3a29dcd221739cacde52edcc681f041907867e0f5cc7e85f172"}, + {file = "pyzmq-27.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ff8d114d14ac671d88c89b9224c63d6c4e5a613fe8acd5594ce53d752a3aafe9"}, + {file = "pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540"}, ] [package.dependencies] @@ -2715,7 +3436,7 @@ description = "JSON Referencing + Python" optional = true python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"dev\"" +markers = "python_version < \"3.14\" and extra == \"dev\"" files = [ {file = "referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0"}, {file = "referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa"}, @@ -2726,17 +3447,34 @@ attrs = ">=22.2.0" rpds-py = ">=0.7.0" typing-extensions = {version = ">=4.4.0", markers = "python_version < \"3.13\""} +[[package]] +name = "referencing" +version = "0.37.0" +description = "JSON Referencing + Python" +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and extra == \"dev\"" +files = [ + {file = "referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231"}, + {file = "referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + [[package]] name = "requests" -version = "2.32.4" +version = "2.32.5" description = "Python HTTP for Humans." optional = true -python-versions = ">=3.8" +python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c"}, - {file = "requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422"}, + {file = "requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6"}, + {file = "requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf"}, ] [package.dependencies] @@ -2799,157 +3537,294 @@ testing = ["pytest (>=8.3.5)"] [[package]] name = "rpds-py" -version = "0.26.0" +version = "0.27.1" description = "Python bindings to Rust's persistent data structures (rpds)" optional = true python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"dev\"" +markers = "python_version < \"3.14\" and extra == \"dev\"" files = [ - {file = "rpds_py-0.26.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:4c70c70f9169692b36307a95f3d8c0a9fcd79f7b4a383aad5eaa0e9718b79b37"}, - {file = "rpds_py-0.26.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:777c62479d12395bfb932944e61e915741e364c843afc3196b694db3d669fcd0"}, - {file = "rpds_py-0.26.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec671691e72dff75817386aa02d81e708b5a7ec0dec6669ec05213ff6b77e1bd"}, - {file = "rpds_py-0.26.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6a1cb5d6ce81379401bbb7f6dbe3d56de537fb8235979843f0d53bc2e9815a79"}, - {file = "rpds_py-0.26.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4f789e32fa1fb6a7bf890e0124e7b42d1e60d28ebff57fe806719abb75f0e9a3"}, - {file = "rpds_py-0.26.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c55b0a669976cf258afd718de3d9ad1b7d1fe0a91cd1ab36f38b03d4d4aeaaf"}, - {file = "rpds_py-0.26.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c70d9ec912802ecfd6cd390dadb34a9578b04f9bcb8e863d0a7598ba5e9e7ccc"}, - {file = "rpds_py-0.26.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3021933c2cb7def39d927b9862292e0f4c75a13d7de70eb0ab06efed4c508c19"}, - {file = "rpds_py-0.26.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8a7898b6ca3b7d6659e55cdac825a2e58c638cbf335cde41f4619e290dd0ad11"}, - {file = "rpds_py-0.26.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:12bff2ad9447188377f1b2794772f91fe68bb4bbfa5a39d7941fbebdbf8c500f"}, - {file = "rpds_py-0.26.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:191aa858f7d4902e975d4cf2f2d9243816c91e9605070aeb09c0a800d187e323"}, - {file = "rpds_py-0.26.0-cp310-cp310-win32.whl", hash = "sha256:b37a04d9f52cb76b6b78f35109b513f6519efb481d8ca4c321f6a3b9580b3f45"}, - {file = "rpds_py-0.26.0-cp310-cp310-win_amd64.whl", hash = "sha256:38721d4c9edd3eb6670437d8d5e2070063f305bfa2d5aa4278c51cedcd508a84"}, - {file = "rpds_py-0.26.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:9e8cb77286025bdb21be2941d64ac6ca016130bfdcd228739e8ab137eb4406ed"}, - {file = "rpds_py-0.26.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5e09330b21d98adc8ccb2dbb9fc6cb434e8908d4c119aeaa772cb1caab5440a0"}, - {file = "rpds_py-0.26.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c9c1b92b774b2e68d11193dc39620d62fd8ab33f0a3c77ecdabe19c179cdbc1"}, - {file = "rpds_py-0.26.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:824e6d3503ab990d7090768e4dfd9e840837bae057f212ff9f4f05ec6d1975e7"}, - {file = "rpds_py-0.26.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8ad7fd2258228bf288f2331f0a6148ad0186b2e3643055ed0db30990e59817a6"}, - {file = "rpds_py-0.26.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0dc23bbb3e06ec1ea72d515fb572c1fea59695aefbffb106501138762e1e915e"}, - {file = "rpds_py-0.26.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d80bf832ac7b1920ee29a426cdca335f96a2b5caa839811803e999b41ba9030d"}, - {file = "rpds_py-0.26.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0919f38f5542c0a87e7b4afcafab6fd2c15386632d249e9a087498571250abe3"}, - {file = "rpds_py-0.26.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d422b945683e409000c888e384546dbab9009bb92f7c0b456e217988cf316107"}, - {file = "rpds_py-0.26.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:77a7711fa562ba2da1aa757e11024ad6d93bad6ad7ede5afb9af144623e5f76a"}, - {file = "rpds_py-0.26.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238e8c8610cb7c29460e37184f6799547f7e09e6a9bdbdab4e8edb90986a2318"}, - {file = "rpds_py-0.26.0-cp311-cp311-win32.whl", hash = "sha256:893b022bfbdf26d7bedb083efeea624e8550ca6eb98bf7fea30211ce95b9201a"}, - {file = "rpds_py-0.26.0-cp311-cp311-win_amd64.whl", hash = "sha256:87a5531de9f71aceb8af041d72fc4cab4943648d91875ed56d2e629bef6d4c03"}, - {file = "rpds_py-0.26.0-cp311-cp311-win_arm64.whl", hash = "sha256:de2713f48c1ad57f89ac25b3cb7daed2156d8e822cf0eca9b96a6f990718cc41"}, - {file = "rpds_py-0.26.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:894514d47e012e794f1350f076c427d2347ebf82f9b958d554d12819849a369d"}, - {file = "rpds_py-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc921b96fa95a097add244da36a1d9e4f3039160d1d30f1b35837bf108c21136"}, - {file = "rpds_py-0.26.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e1157659470aa42a75448b6e943c895be8c70531c43cb78b9ba990778955582"}, - {file = "rpds_py-0.26.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:521ccf56f45bb3a791182dc6b88ae5f8fa079dd705ee42138c76deb1238e554e"}, - {file = "rpds_py-0.26.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9def736773fd56b305c0eef698be5192c77bfa30d55a0e5885f80126c4831a15"}, - {file = "rpds_py-0.26.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdad4ea3b4513b475e027be79e5a0ceac8ee1c113a1a11e5edc3c30c29f964d8"}, - {file = "rpds_py-0.26.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82b165b07f416bdccf5c84546a484cc8f15137ca38325403864bfdf2b5b72f6a"}, - {file = "rpds_py-0.26.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d04cab0a54b9dba4d278fe955a1390da3cf71f57feb78ddc7cb67cbe0bd30323"}, - {file = "rpds_py-0.26.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:79061ba1a11b6a12743a2b0f72a46aa2758613d454aa6ba4f5a265cc48850158"}, - {file = "rpds_py-0.26.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f405c93675d8d4c5ac87364bb38d06c988e11028a64b52a47158a355079661f3"}, - {file = "rpds_py-0.26.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dafd4c44b74aa4bed4b250f1aed165b8ef5de743bcca3b88fc9619b6087093d2"}, - {file = "rpds_py-0.26.0-cp312-cp312-win32.whl", hash = "sha256:3da5852aad63fa0c6f836f3359647870e21ea96cf433eb393ffa45263a170d44"}, - {file = "rpds_py-0.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:cf47cfdabc2194a669dcf7a8dbba62e37a04c5041d2125fae0233b720da6f05c"}, - {file = "rpds_py-0.26.0-cp312-cp312-win_arm64.whl", hash = "sha256:20ab1ae4fa534f73647aad289003f1104092890849e0266271351922ed5574f8"}, - {file = "rpds_py-0.26.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:696764a5be111b036256c0b18cd29783fab22154690fc698062fc1b0084b511d"}, - {file = "rpds_py-0.26.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1e6c15d2080a63aaed876e228efe4f814bc7889c63b1e112ad46fdc8b368b9e1"}, - {file = "rpds_py-0.26.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:390e3170babf42462739a93321e657444f0862c6d722a291accc46f9d21ed04e"}, - {file = "rpds_py-0.26.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7da84c2c74c0f5bc97d853d9e17bb83e2dcafcff0dc48286916001cc114379a1"}, - {file = "rpds_py-0.26.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c5fe114a6dd480a510b6d3661d09d67d1622c4bf20660a474507aaee7eeeee9"}, - {file = "rpds_py-0.26.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3100b3090269f3a7ea727b06a6080d4eb7439dca4c0e91a07c5d133bb1727ea7"}, - {file = "rpds_py-0.26.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c03c9b0c64afd0320ae57de4c982801271c0c211aa2d37f3003ff5feb75bb04"}, - {file = "rpds_py-0.26.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5963b72ccd199ade6ee493723d18a3f21ba7d5b957017607f815788cef50eaf1"}, - {file = "rpds_py-0.26.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9da4e873860ad5bab3291438525cae80169daecbfafe5657f7f5fb4d6b3f96b9"}, - {file = "rpds_py-0.26.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5afaddaa8e8c7f1f7b4c5c725c0070b6eed0228f705b90a1732a48e84350f4e9"}, - {file = "rpds_py-0.26.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4916dc96489616a6f9667e7526af8fa693c0fdb4f3acb0e5d9f4400eb06a47ba"}, - {file = "rpds_py-0.26.0-cp313-cp313-win32.whl", hash = "sha256:2a343f91b17097c546b93f7999976fd6c9d5900617aa848c81d794e062ab302b"}, - {file = "rpds_py-0.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:0a0b60701f2300c81b2ac88a5fb893ccfa408e1c4a555a77f908a2596eb875a5"}, - {file = "rpds_py-0.26.0-cp313-cp313-win_arm64.whl", hash = "sha256:257d011919f133a4746958257f2c75238e3ff54255acd5e3e11f3ff41fd14256"}, - {file = "rpds_py-0.26.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:529c8156d7506fba5740e05da8795688f87119cce330c244519cf706a4a3d618"}, - {file = "rpds_py-0.26.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f53ec51f9d24e9638a40cabb95078ade8c99251945dad8d57bf4aabe86ecee35"}, - {file = "rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab504c4d654e4a29558eaa5bb8cea5fdc1703ea60a8099ffd9c758472cf913f"}, - {file = "rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fd0641abca296bc1a00183fe44f7fced8807ed49d501f188faa642d0e4975b83"}, - {file = "rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b312fecc1d017b5327afa81d4da1480f51c68810963a7336d92203dbb3d4f1"}, - {file = "rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c741107203954f6fc34d3066d213d0a0c40f7bb5aafd698fb39888af277c70d8"}, - {file = "rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc3e55a7db08dc9a6ed5fb7103019d2c1a38a349ac41901f9f66d7f95750942f"}, - {file = "rpds_py-0.26.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9e851920caab2dbcae311fd28f4313c6953993893eb5c1bb367ec69d9a39e7ed"}, - {file = "rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dfbf280da5f876d0b00c81f26bedce274e72a678c28845453885a9b3c22ae632"}, - {file = "rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:1cc81d14ddfa53d7f3906694d35d54d9d3f850ef8e4e99ee68bc0d1e5fed9a9c"}, - {file = "rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dca83c498b4650a91efcf7b88d669b170256bf8017a5db6f3e06c2bf031f57e0"}, - {file = "rpds_py-0.26.0-cp313-cp313t-win32.whl", hash = "sha256:4d11382bcaf12f80b51d790dee295c56a159633a8e81e6323b16e55d81ae37e9"}, - {file = "rpds_py-0.26.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff110acded3c22c033e637dd8896e411c7d3a11289b2edf041f86663dbc791e9"}, - {file = "rpds_py-0.26.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:da619979df60a940cd434084355c514c25cf8eb4cf9a508510682f6c851a4f7a"}, - {file = "rpds_py-0.26.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ea89a2458a1a75f87caabefe789c87539ea4e43b40f18cff526052e35bbb4fdf"}, - {file = "rpds_py-0.26.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feac1045b3327a45944e7dcbeb57530339f6b17baff154df51ef8b0da34c8c12"}, - {file = "rpds_py-0.26.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b818a592bd69bfe437ee8368603d4a2d928c34cffcdf77c2e761a759ffd17d20"}, - {file = "rpds_py-0.26.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a8b0dd8648709b62d9372fc00a57466f5fdeefed666afe3fea5a6c9539a0331"}, - {file = "rpds_py-0.26.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6d3498ad0df07d81112aa6ec6c95a7e7b1ae00929fb73e7ebee0f3faaeabad2f"}, - {file = "rpds_py-0.26.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24a4146ccb15be237fdef10f331c568e1b0e505f8c8c9ed5d67759dac58ac246"}, - {file = "rpds_py-0.26.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a9a63785467b2d73635957d32a4f6e73d5e4df497a16a6392fa066b753e87387"}, - {file = "rpds_py-0.26.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:de4ed93a8c91debfd5a047be327b7cc8b0cc6afe32a716bbbc4aedca9e2a83af"}, - {file = "rpds_py-0.26.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:caf51943715b12af827696ec395bfa68f090a4c1a1d2509eb4e2cb69abbbdb33"}, - {file = "rpds_py-0.26.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4a59e5bc386de021f56337f757301b337d7ab58baa40174fb150accd480bc953"}, - {file = "rpds_py-0.26.0-cp314-cp314-win32.whl", hash = "sha256:92c8db839367ef16a662478f0a2fe13e15f2227da3c1430a782ad0f6ee009ec9"}, - {file = "rpds_py-0.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:b0afb8cdd034150d4d9f53926226ed27ad15b7f465e93d7468caaf5eafae0d37"}, - {file = "rpds_py-0.26.0-cp314-cp314-win_arm64.whl", hash = "sha256:ca3f059f4ba485d90c8dc75cb5ca897e15325e4e609812ce57f896607c1c0867"}, - {file = "rpds_py-0.26.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:5afea17ab3a126006dc2f293b14ffc7ef3c85336cf451564a0515ed7648033da"}, - {file = "rpds_py-0.26.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:69f0c0a3df7fd3a7eec50a00396104bb9a843ea6d45fcc31c2d5243446ffd7a7"}, - {file = "rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:801a71f70f9813e82d2513c9a96532551fce1e278ec0c64610992c49c04c2dad"}, - {file = "rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:df52098cde6d5e02fa75c1f6244f07971773adb4a26625edd5c18fee906fa84d"}, - {file = "rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9bc596b30f86dc6f0929499c9e574601679d0341a0108c25b9b358a042f51bca"}, - {file = "rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9dfbe56b299cf5875b68eb6f0ebaadc9cac520a1989cac0db0765abfb3709c19"}, - {file = "rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac64f4b2bdb4ea622175c9ab7cf09444e412e22c0e02e906978b3b488af5fde8"}, - {file = "rpds_py-0.26.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:181ef9b6bbf9845a264f9aa45c31836e9f3c1f13be565d0d010e964c661d1e2b"}, - {file = "rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:49028aa684c144ea502a8e847d23aed5e4c2ef7cadfa7d5eaafcb40864844b7a"}, - {file = "rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e5d524d68a474a9688336045bbf76cb0def88549c1b2ad9dbfec1fb7cfbe9170"}, - {file = "rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c1851f429b822831bd2edcbe0cfd12ee9ea77868f8d3daf267b189371671c80e"}, - {file = "rpds_py-0.26.0-cp314-cp314t-win32.whl", hash = "sha256:7bdb17009696214c3b66bb3590c6d62e14ac5935e53e929bcdbc5a495987a84f"}, - {file = "rpds_py-0.26.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f14440b9573a6f76b4ee4770c13f0b5921f71dde3b6fcb8dabbefd13b7fe05d7"}, - {file = "rpds_py-0.26.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:7a48af25d9b3c15684059d0d1fc0bc30e8eee5ca521030e2bffddcab5be40226"}, - {file = "rpds_py-0.26.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0c71c2f6bf36e61ee5c47b2b9b5d47e4d1baad6426bfed9eea3e858fc6ee8806"}, - {file = "rpds_py-0.26.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d815d48b1804ed7867b539236b6dd62997850ca1c91cad187f2ddb1b7bbef19"}, - {file = "rpds_py-0.26.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:84cfbd4d4d2cdeb2be61a057a258d26b22877266dd905809e94172dff01a42ae"}, - {file = "rpds_py-0.26.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fbaa70553ca116c77717f513e08815aec458e6b69a028d4028d403b3bc84ff37"}, - {file = "rpds_py-0.26.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39bfea47c375f379d8e87ab4bb9eb2c836e4f2069f0f65731d85e55d74666387"}, - {file = "rpds_py-0.26.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1533b7eb683fb5f38c1d68a3c78f5fdd8f1412fa6b9bf03b40f450785a0ab915"}, - {file = "rpds_py-0.26.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c5ab0ee51f560d179b057555b4f601b7df909ed31312d301b99f8b9fc6028284"}, - {file = "rpds_py-0.26.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:e5162afc9e0d1f9cae3b577d9c29ddbab3505ab39012cb794d94a005825bde21"}, - {file = "rpds_py-0.26.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:43f10b007033f359bc3fa9cd5e6c1e76723f056ffa9a6b5c117cc35720a80292"}, - {file = "rpds_py-0.26.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:e3730a48e5622e598293eee0762b09cff34dd3f271530f47b0894891281f051d"}, - {file = "rpds_py-0.26.0-cp39-cp39-win32.whl", hash = "sha256:4b1f66eb81eab2e0ff5775a3a312e5e2e16bf758f7b06be82fb0d04078c7ac51"}, - {file = "rpds_py-0.26.0-cp39-cp39-win_amd64.whl", hash = "sha256:519067e29f67b5c90e64fb1a6b6e9d2ec0ba28705c51956637bac23a2f4ddae1"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3c0909c5234543ada2515c05dc08595b08d621ba919629e94427e8e03539c958"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c1fb0cda2abcc0ac62f64e2ea4b4e64c57dfd6b885e693095460c61bde7bb18e"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84d142d2d6cf9b31c12aa4878d82ed3b2324226270b89b676ac62ccd7df52d08"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a547e21c5610b7e9093d870be50682a6a6cf180d6da0f42c47c306073bfdbbf6"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:35e9a70a0f335371275cdcd08bc5b8051ac494dd58bff3bbfb421038220dc871"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0dfa6115c6def37905344d56fb54c03afc49104e2ca473d5dedec0f6606913b4"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:313cfcd6af1a55a286a3c9a25f64af6d0e46cf60bc5798f1db152d97a216ff6f"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f7bf2496fa563c046d05e4d232d7b7fd61346e2402052064b773e5c378bf6f73"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:aa81873e2c8c5aa616ab8e017a481a96742fdf9313c40f14338ca7dbf50cb55f"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:68ffcf982715f5b5b7686bdd349ff75d422e8f22551000c24b30eaa1b7f7ae84"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6188de70e190847bb6db3dc3981cbadff87d27d6fe9b4f0e18726d55795cee9b"}, - {file = "rpds_py-0.26.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1c962145c7473723df9722ba4c058de12eb5ebedcb4e27e7d902920aa3831ee8"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f61a9326f80ca59214d1cceb0a09bb2ece5b2563d4e0cd37bfd5515c28510674"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:183f857a53bcf4b1b42ef0f57ca553ab56bdd170e49d8091e96c51c3d69ca696"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:941c1cfdf4799d623cf3aa1d326a6b4fdb7a5799ee2687f3516738216d2262fb"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72a8d9564a717ee291f554eeb4bfeafe2309d5ec0aa6c475170bdab0f9ee8e88"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:511d15193cbe013619dd05414c35a7dedf2088fcee93c6bbb7c77859765bd4e8"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aea1f9741b603a8d8fedb0ed5502c2bc0accbc51f43e2ad1337fe7259c2b77a5"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4019a9d473c708cf2f16415688ef0b4639e07abaa569d72f74745bbeffafa2c7"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:093d63b4b0f52d98ebae33b8c50900d3d67e0666094b1be7a12fffd7f65de74b"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:2abe21d8ba64cded53a2a677e149ceb76dcf44284202d737178afe7ba540c1eb"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:4feb7511c29f8442cbbc28149a92093d32e815a28aa2c50d333826ad2a20fdf0"}, - {file = "rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e99685fc95d386da368013e7fb4269dd39c30d99f812a8372d62f244f662709c"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a90a13408a7a856b87be8a9f008fff53c5080eea4e4180f6c2e546e4a972fb5d"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:3ac51b65e8dc76cf4949419c54c5528adb24fc721df722fd452e5fbc236f5c40"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:59b2093224a18c6508d95cfdeba8db9cbfd6f3494e94793b58972933fcee4c6d"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4f01a5d6444a3258b00dc07b6ea4733e26f8072b788bef750baa37b370266137"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b6e2c12160c72aeda9d1283e612f68804621f448145a210f1bf1d79151c47090"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cb28c1f569f8d33b2b5dcd05d0e6ef7005d8639c54c2f0be824f05aedf715255"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1766b5724c3f779317d5321664a343c07773c8c5fd1532e4039e6cc7d1a815be"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b6d9e5a2ed9c4988c8f9b28b3bc0e3e5b1aaa10c28d210a594ff3a8c02742daf"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:b5f7a446ddaf6ca0fad9a5535b56fbfc29998bf0e0b450d174bbec0d600e1d72"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:eed5ac260dd545fbc20da5f4f15e7efe36a55e0e7cf706e4ec005b491a9546a0"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:582462833ba7cee52e968b0341b85e392ae53d44c0f9af6a5927c80e539a8b67"}, - {file = "rpds_py-0.26.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:69a607203441e07e9a8a529cff1d5b73f6a160f22db1097211e6212a68567d11"}, - {file = "rpds_py-0.26.0.tar.gz", hash = "sha256:20dae58a859b0906f0685642e591056f1e787f3a8b39c8e8749a45dc7d26bdb0"}, + {file = "rpds_py-0.27.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:68afeec26d42ab3b47e541b272166a0b4400313946871cba3ed3a4fc0cab1cef"}, + {file = "rpds_py-0.27.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:74e5b2f7bb6fa38b1b10546d27acbacf2a022a8b5543efb06cfebc72a59c85be"}, + {file = "rpds_py-0.27.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9024de74731df54546fab0bfbcdb49fae19159ecaecfc8f37c18d2c7e2c0bd61"}, + {file = "rpds_py-0.27.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:31d3ebadefcd73b73928ed0b2fd696f7fefda8629229f81929ac9c1854d0cffb"}, + {file = "rpds_py-0.27.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b2e7f8f169d775dd9092a1743768d771f1d1300453ddfe6325ae3ab5332b4657"}, + {file = "rpds_py-0.27.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d905d16f77eb6ab2e324e09bfa277b4c8e5e6b8a78a3e7ff8f3cdf773b4c013"}, + {file = "rpds_py-0.27.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50c946f048209e6362e22576baea09193809f87687a95a8db24e5fbdb307b93a"}, + {file = "rpds_py-0.27.1-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:3deab27804d65cd8289eb814c2c0e807c4b9d9916c9225e363cb0cf875eb67c1"}, + {file = "rpds_py-0.27.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8b61097f7488de4be8244c89915da8ed212832ccf1e7c7753a25a394bf9b1f10"}, + {file = "rpds_py-0.27.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8a3f29aba6e2d7d90528d3c792555a93497fe6538aa65eb675b44505be747808"}, + {file = "rpds_py-0.27.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd6cd0485b7d347304067153a6dc1d73f7d4fd995a396ef32a24d24b8ac63ac8"}, + {file = "rpds_py-0.27.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6f4461bf931108c9fa226ffb0e257c1b18dc2d44cd72b125bec50ee0ab1248a9"}, + {file = "rpds_py-0.27.1-cp310-cp310-win32.whl", hash = "sha256:ee5422d7fb21f6a00c1901bf6559c49fee13a5159d0288320737bbf6585bd3e4"}, + {file = "rpds_py-0.27.1-cp310-cp310-win_amd64.whl", hash = "sha256:3e039aabf6d5f83c745d5f9a0a381d031e9ed871967c0a5c38d201aca41f3ba1"}, + {file = "rpds_py-0.27.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:be898f271f851f68b318872ce6ebebbc62f303b654e43bf72683dbdc25b7c881"}, + {file = "rpds_py-0.27.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:62ac3d4e3e07b58ee0ddecd71d6ce3b1637de2d373501412df395a0ec5f9beb5"}, + {file = "rpds_py-0.27.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4708c5c0ceb2d034f9991623631d3d23cb16e65c83736ea020cdbe28d57c0a0e"}, + {file = "rpds_py-0.27.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:abfa1171a9952d2e0002aba2ad3780820b00cc3d9c98c6630f2e93271501f66c"}, + {file = "rpds_py-0.27.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4b507d19f817ebaca79574b16eb2ae412e5c0835542c93fe9983f1e432aca195"}, + {file = "rpds_py-0.27.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:168b025f8fd8d8d10957405f3fdcef3dc20f5982d398f90851f4abc58c566c52"}, + {file = "rpds_py-0.27.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb56c6210ef77caa58e16e8c17d35c63fe3f5b60fd9ba9d424470c3400bcf9ed"}, + {file = "rpds_py-0.27.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:d252f2d8ca0195faa707f8eb9368955760880b2b42a8ee16d382bf5dd807f89a"}, + {file = "rpds_py-0.27.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6e5e54da1e74b91dbc7996b56640f79b195d5925c2b78efaa8c5d53e1d88edde"}, + {file = "rpds_py-0.27.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ffce0481cc6e95e5b3f0a47ee17ffbd234399e6d532f394c8dce320c3b089c21"}, + {file = "rpds_py-0.27.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a205fdfe55c90c2cd8e540ca9ceba65cbe6629b443bc05db1f590a3db8189ff9"}, + {file = "rpds_py-0.27.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:689fb5200a749db0415b092972e8eba85847c23885c8543a8b0f5c009b1a5948"}, + {file = "rpds_py-0.27.1-cp311-cp311-win32.whl", hash = "sha256:3182af66048c00a075010bc7f4860f33913528a4b6fc09094a6e7598e462fe39"}, + {file = "rpds_py-0.27.1-cp311-cp311-win_amd64.whl", hash = "sha256:b4938466c6b257b2f5c4ff98acd8128ec36b5059e5c8f8372d79316b1c36bb15"}, + {file = "rpds_py-0.27.1-cp311-cp311-win_arm64.whl", hash = "sha256:2f57af9b4d0793e53266ee4325535a31ba48e2f875da81a9177c9926dfa60746"}, + {file = "rpds_py-0.27.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ae2775c1973e3c30316892737b91f9283f9908e3cc7625b9331271eaaed7dc90"}, + {file = "rpds_py-0.27.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2643400120f55c8a96f7c9d858f7be0c88d383cd4653ae2cf0d0c88f668073e5"}, + {file = "rpds_py-0.27.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16323f674c089b0360674a4abd28d5042947d54ba620f72514d69be4ff64845e"}, + {file = "rpds_py-0.27.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9a1f4814b65eacac94a00fc9a526e3fdafd78e439469644032032d0d63de4881"}, + {file = "rpds_py-0.27.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ba32c16b064267b22f1850a34051121d423b6f7338a12b9459550eb2096e7ec"}, + {file = "rpds_py-0.27.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5c20f33fd10485b80f65e800bbe5f6785af510b9f4056c5a3c612ebc83ba6cb"}, + {file = "rpds_py-0.27.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:466bfe65bd932da36ff279ddd92de56b042f2266d752719beb97b08526268ec5"}, + {file = "rpds_py-0.27.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:41e532bbdcb57c92ba3be62c42e9f096431b4cf478da9bc3bc6ce5c38ab7ba7a"}, + {file = "rpds_py-0.27.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f149826d742b406579466283769a8ea448eed82a789af0ed17b0cd5770433444"}, + {file = "rpds_py-0.27.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80c60cfb5310677bd67cb1e85a1e8eb52e12529545441b43e6f14d90b878775a"}, + {file = "rpds_py-0.27.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7ee6521b9baf06085f62ba9c7a3e5becffbc32480d2f1b351559c001c38ce4c1"}, + {file = "rpds_py-0.27.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a512c8263249a9d68cac08b05dd59d2b3f2061d99b322813cbcc14c3c7421998"}, + {file = "rpds_py-0.27.1-cp312-cp312-win32.whl", hash = "sha256:819064fa048ba01b6dadc5116f3ac48610435ac9a0058bbde98e569f9e785c39"}, + {file = "rpds_py-0.27.1-cp312-cp312-win_amd64.whl", hash = "sha256:d9199717881f13c32c4046a15f024971a3b78ad4ea029e8da6b86e5aa9cf4594"}, + {file = "rpds_py-0.27.1-cp312-cp312-win_arm64.whl", hash = "sha256:33aa65b97826a0e885ef6e278fbd934e98cdcfed80b63946025f01e2f5b29502"}, + {file = "rpds_py-0.27.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e4b9fcfbc021633863a37e92571d6f91851fa656f0180246e84cbd8b3f6b329b"}, + {file = "rpds_py-0.27.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1441811a96eadca93c517d08df75de45e5ffe68aa3089924f963c782c4b898cf"}, + {file = "rpds_py-0.27.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55266dafa22e672f5a4f65019015f90336ed31c6383bd53f5e7826d21a0e0b83"}, + {file = "rpds_py-0.27.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d78827d7ac08627ea2c8e02c9e5b41180ea5ea1f747e9db0915e3adf36b62dcf"}, + {file = "rpds_py-0.27.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae92443798a40a92dc5f0b01d8a7c93adde0c4dc965310a29ae7c64d72b9fad2"}, + {file = "rpds_py-0.27.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c46c9dd2403b66a2a3b9720ec4b74d4ab49d4fabf9f03dfdce2d42af913fe8d0"}, + {file = "rpds_py-0.27.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2efe4eb1d01b7f5f1939f4ef30ecea6c6b3521eec451fb93191bf84b2a522418"}, + {file = "rpds_py-0.27.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:15d3b4d83582d10c601f481eca29c3f138d44c92187d197aff663a269197c02d"}, + {file = "rpds_py-0.27.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4ed2e16abbc982a169d30d1a420274a709949e2cbdef119fe2ec9d870b42f274"}, + {file = "rpds_py-0.27.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a75f305c9b013289121ec0f1181931975df78738cdf650093e6b86d74aa7d8dd"}, + {file = "rpds_py-0.27.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:67ce7620704745881a3d4b0ada80ab4d99df390838839921f99e63c474f82cf2"}, + {file = "rpds_py-0.27.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d992ac10eb86d9b6f369647b6a3f412fc0075cfd5d799530e84d335e440a002"}, + {file = "rpds_py-0.27.1-cp313-cp313-win32.whl", hash = "sha256:4f75e4bd8ab8db624e02c8e2fc4063021b58becdbe6df793a8111d9343aec1e3"}, + {file = "rpds_py-0.27.1-cp313-cp313-win_amd64.whl", hash = "sha256:f9025faafc62ed0b75a53e541895ca272815bec18abe2249ff6501c8f2e12b83"}, + {file = "rpds_py-0.27.1-cp313-cp313-win_arm64.whl", hash = "sha256:ed10dc32829e7d222b7d3b93136d25a406ba9788f6a7ebf6809092da1f4d279d"}, + {file = "rpds_py-0.27.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:92022bbbad0d4426e616815b16bc4127f83c9a74940e1ccf3cfe0b387aba0228"}, + {file = "rpds_py-0.27.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:47162fdab9407ec3f160805ac3e154df042e577dd53341745fc7fb3f625e6d92"}, + {file = "rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb89bec23fddc489e5d78b550a7b773557c9ab58b7946154a10a6f7a214a48b2"}, + {file = "rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e48af21883ded2b3e9eb48cb7880ad8598b31ab752ff3be6457001d78f416723"}, + {file = "rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6f5b7bd8e219ed50299e58551a410b64daafb5017d54bbe822e003856f06a802"}, + {file = "rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08f1e20bccf73b08d12d804d6e1c22ca5530e71659e6673bce31a6bb71c1e73f"}, + {file = "rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0dc5dceeaefcc96dc192e3a80bbe1d6c410c469e97bdd47494a7d930987f18b2"}, + {file = "rpds_py-0.27.1-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:d76f9cc8665acdc0c9177043746775aa7babbf479b5520b78ae4002d889f5c21"}, + {file = "rpds_py-0.27.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:134fae0e36022edad8290a6661edf40c023562964efea0cc0ec7f5d392d2aaef"}, + {file = "rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb11a4f1b2b63337cfd3b4d110af778a59aae51c81d195768e353d8b52f88081"}, + {file = "rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:13e608ac9f50a0ed4faec0e90ece76ae33b34c0e8656e3dceb9a7db994c692cd"}, + {file = "rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dd2135527aa40f061350c3f8f89da2644de26cd73e4de458e79606384f4f68e7"}, + {file = "rpds_py-0.27.1-cp313-cp313t-win32.whl", hash = "sha256:3020724ade63fe320a972e2ffd93b5623227e684315adce194941167fee02688"}, + {file = "rpds_py-0.27.1-cp313-cp313t-win_amd64.whl", hash = "sha256:8ee50c3e41739886606388ba3ab3ee2aae9f35fb23f833091833255a31740797"}, + {file = "rpds_py-0.27.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:acb9aafccaae278f449d9c713b64a9e68662e7799dbd5859e2c6b3c67b56d334"}, + {file = "rpds_py-0.27.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b7fb801aa7f845ddf601c49630deeeccde7ce10065561d92729bfe81bd21fb33"}, + {file = "rpds_py-0.27.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe0dd05afb46597b9a2e11c351e5e4283c741237e7f617ffb3252780cca9336a"}, + {file = "rpds_py-0.27.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b6dfb0e058adb12d8b1d1b25f686e94ffa65d9995a5157afe99743bf7369d62b"}, + {file = "rpds_py-0.27.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed090ccd235f6fa8bb5861684567f0a83e04f52dfc2e5c05f2e4b1309fcf85e7"}, + {file = "rpds_py-0.27.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bf876e79763eecf3e7356f157540d6a093cef395b65514f17a356f62af6cc136"}, + {file = "rpds_py-0.27.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:12ed005216a51b1d6e2b02a7bd31885fe317e45897de81d86dcce7d74618ffff"}, + {file = "rpds_py-0.27.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:ee4308f409a40e50593c7e3bb8cbe0b4d4c66d1674a316324f0c2f5383b486f9"}, + {file = "rpds_py-0.27.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0b08d152555acf1f455154d498ca855618c1378ec810646fcd7c76416ac6dc60"}, + {file = "rpds_py-0.27.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:dce51c828941973a5684d458214d3a36fcd28da3e1875d659388f4f9f12cc33e"}, + {file = "rpds_py-0.27.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:c1476d6f29eb81aa4151c9a31219b03f1f798dc43d8af1250a870735516a1212"}, + {file = "rpds_py-0.27.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ce0cac322b0d69b63c9cdb895ee1b65805ec9ffad37639f291dd79467bee675"}, + {file = "rpds_py-0.27.1-cp314-cp314-win32.whl", hash = "sha256:dfbfac137d2a3d0725758cd141f878bf4329ba25e34979797c89474a89a8a3a3"}, + {file = "rpds_py-0.27.1-cp314-cp314-win_amd64.whl", hash = "sha256:a6e57b0abfe7cc513450fcf529eb486b6e4d3f8aee83e92eb5f1ef848218d456"}, + {file = "rpds_py-0.27.1-cp314-cp314-win_arm64.whl", hash = "sha256:faf8d146f3d476abfee026c4ae3bdd9ca14236ae4e4c310cbd1cf75ba33d24a3"}, + {file = "rpds_py-0.27.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:ba81d2b56b6d4911ce735aad0a1d4495e808b8ee4dc58715998741a26874e7c2"}, + {file = "rpds_py-0.27.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:84f7d509870098de0e864cad0102711c1e24e9b1a50ee713b65928adb22269e4"}, + {file = "rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9e960fc78fecd1100539f14132425e1d5fe44ecb9239f8f27f079962021523e"}, + {file = "rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:62f85b665cedab1a503747617393573995dac4600ff51869d69ad2f39eb5e817"}, + {file = "rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fed467af29776f6556250c9ed85ea5a4dd121ab56a5f8b206e3e7a4c551e48ec"}, + {file = "rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2729615f9d430af0ae6b36cf042cb55c0936408d543fb691e1a9e36648fd35a"}, + {file = "rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b207d881a9aef7ba753d69c123a35d96ca7cb808056998f6b9e8747321f03b8"}, + {file = "rpds_py-0.27.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:639fd5efec029f99b79ae47e5d7e00ad8a773da899b6309f6786ecaf22948c48"}, + {file = "rpds_py-0.27.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fecc80cb2a90e28af8a9b366edacf33d7a91cbfe4c2c4544ea1246e949cfebeb"}, + {file = "rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42a89282d711711d0a62d6f57d81aa43a1368686c45bc1c46b7f079d55692734"}, + {file = "rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:cf9931f14223de59551ab9d38ed18d92f14f055a5f78c1d8ad6493f735021bbb"}, + {file = "rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f39f58a27cc6e59f432b568ed8429c7e1641324fbe38131de852cd77b2d534b0"}, + {file = "rpds_py-0.27.1-cp314-cp314t-win32.whl", hash = "sha256:d5fa0ee122dc09e23607a28e6d7b150da16c662e66409bbe85230e4c85bb528a"}, + {file = "rpds_py-0.27.1-cp314-cp314t-win_amd64.whl", hash = "sha256:6567d2bb951e21232c2f660c24cf3470bb96de56cdcb3f071a83feeaff8a2772"}, + {file = "rpds_py-0.27.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c918c65ec2e42c2a78d19f18c553d77319119bf43aa9e2edf7fb78d624355527"}, + {file = "rpds_py-0.27.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1fea2b1a922c47c51fd07d656324531adc787e415c8b116530a1d29c0516c62d"}, + {file = "rpds_py-0.27.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbf94c58e8e0cd6b6f38d8de67acae41b3a515c26169366ab58bdca4a6883bb8"}, + {file = "rpds_py-0.27.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c2a8fed130ce946d5c585eddc7c8eeef0051f58ac80a8ee43bd17835c144c2cc"}, + {file = "rpds_py-0.27.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:037a2361db72ee98d829bc2c5b7cc55598ae0a5e0ec1823a56ea99374cfd73c1"}, + {file = "rpds_py-0.27.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5281ed1cc1d49882f9997981c88df1a22e140ab41df19071222f7e5fc4e72125"}, + {file = "rpds_py-0.27.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fd50659a069c15eef8aa3d64bbef0d69fd27bb4a50c9ab4f17f83a16cbf8905"}, + {file = "rpds_py-0.27.1-cp39-cp39-manylinux_2_31_riscv64.whl", hash = "sha256:c4b676c4ae3921649a15d28ed10025548e9b561ded473aa413af749503c6737e"}, + {file = "rpds_py-0.27.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:079bc583a26db831a985c5257797b2b5d3affb0386e7ff886256762f82113b5e"}, + {file = "rpds_py-0.27.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:4e44099bd522cba71a2c6b97f68e19f40e7d85399de899d66cdb67b32d7cb786"}, + {file = "rpds_py-0.27.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:e202e6d4188e53c6661af813b46c37ca2c45e497fc558bacc1a7630ec2695aec"}, + {file = "rpds_py-0.27.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f41f814b8eaa48768d1bb551591f6ba45f87ac76899453e8ccd41dba1289b04b"}, + {file = "rpds_py-0.27.1-cp39-cp39-win32.whl", hash = "sha256:9e71f5a087ead99563c11fdaceee83ee982fd39cf67601f4fd66cb386336ee52"}, + {file = "rpds_py-0.27.1-cp39-cp39-win_amd64.whl", hash = "sha256:71108900c9c3c8590697244b9519017a400d9ba26a36c48381b3f64743a44aab"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:7ba22cb9693df986033b91ae1d7a979bc399237d45fccf875b76f62bb9e52ddf"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b640501be9288c77738b5492b3fd3abc4ba95c50c2e41273c8a1459f08298d3"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb08b65b93e0c6dd70aac7f7890a9c0938d5ec71d5cb32d45cf844fb8ae47636"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d7ff07d696a7a38152ebdb8212ca9e5baab56656749f3d6004b34ab726b550b8"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fb7c72262deae25366e3b6c0c0ba46007967aea15d1eea746e44ddba8ec58dcc"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7b002cab05d6339716b03a4a3a2ce26737f6231d7b523f339fa061d53368c9d8"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23f6b69d1c26c4704fec01311963a41d7de3ee0570a84ebde4d544e5a1859ffc"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:530064db9146b247351f2a0250b8f00b289accea4596a033e94be2389977de71"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7b90b0496570bd6b0321724a330d8b545827c4df2034b6ddfc5f5275f55da2ad"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:879b0e14a2da6a1102a3fc8af580fc1ead37e6d6692a781bd8c83da37429b5ab"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:0d807710df3b5faa66c731afa162ea29717ab3be17bdc15f90f2d9f183da4059"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:3adc388fc3afb6540aec081fa59e6e0d3908722771aa1e37ffe22b220a436f0b"}, + {file = "rpds_py-0.27.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c796c0c1cc68cb08b0284db4229f5af76168172670c74908fdbd4b7d7f515819"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:cdfe4bb2f9fe7458b7453ad3c33e726d6d1c7c0a72960bcc23800d77384e42df"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:8fabb8fd848a5f75a2324e4a84501ee3a5e3c78d8603f83475441866e60b94a3"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eda8719d598f2f7f3e0f885cba8646644b55a187762bec091fa14a2b819746a9"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3c64d07e95606ec402a0a1c511fe003873fa6af630bda59bac77fac8b4318ebc"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:93a2ed40de81bcff59aabebb626562d48332f3d028ca2036f1d23cbb52750be4"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:387ce8c44ae94e0ec50532d9cb0edce17311024c9794eb196b90e1058aadeb66"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aaf94f812c95b5e60ebaf8bfb1898a7d7cb9c1af5744d4a67fa47796e0465d4e"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:4848ca84d6ded9b58e474dfdbad4b8bfb450344c0551ddc8d958bf4b36aa837c"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2bde09cbcf2248b73c7c323be49b280180ff39fadcfe04e7b6f54a678d02a7cf"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:94c44ee01fd21c9058f124d2d4f0c9dc7634bec93cd4b38eefc385dabe71acbf"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:df8b74962e35c9249425d90144e721eed198e6555a0e22a563d29fe4486b51f6"}, + {file = "rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:dc23e6820e3b40847e2f4a7726462ba0cf53089512abe9ee16318c366494c17a"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:aa8933159edc50be265ed22b401125c9eebff3171f570258854dbce3ecd55475"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a50431bf02583e21bf273c71b89d710e7a710ad5e39c725b14e685610555926f"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78af06ddc7fe5cc0e967085a9115accee665fb912c22a3f54bad70cc65b05fe6"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:70d0738ef8fee13c003b100c2fbd667ec4f133468109b3472d249231108283a3"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2f6fd8a1cea5bbe599b6e78a6e5ee08db434fc8ffea51ff201c8765679698b3"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8177002868d1426305bb5de1e138161c2ec9eb2d939be38291d7c431c4712df8"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:008b839781d6c9bf3b6a8984d1d8e56f0ec46dc56df61fd669c49b58ae800400"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:a55b9132bb1ade6c734ddd2759c8dc132aa63687d259e725221f106b83a0e485"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a46fdec0083a26415f11d5f236b79fa1291c32aaa4a17684d82f7017a1f818b1"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:8a63b640a7845f2bdd232eb0d0a4a2dd939bcdd6c57e6bb134526487f3160ec5"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:7e32721e5d4922deaaf963469d795d5bde6093207c52fec719bd22e5d1bedbc4"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:2c426b99a068601b5f4623573df7a7c3d72e87533a2dd2253353a03e7502566c"}, + {file = "rpds_py-0.27.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:4fc9b7fe29478824361ead6e14e4f5aed570d477e06088826537e202d25fe859"}, + {file = "rpds_py-0.27.1.tar.gz", hash = "sha256:26a1c73171d10b7acccbded82bf6a586ab8203601e565badc74bbbf8bc5a10f8"}, +] + +[[package]] +name = "rpds-py" +version = "0.28.0" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = true +python-versions = ">=3.10" +groups = ["main"] +markers = "python_version >= \"3.14\" and extra == \"dev\"" +files = [ + {file = "rpds_py-0.28.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7b6013db815417eeb56b2d9d7324e64fcd4fa289caeee6e7a78b2e11fc9b438a"}, + {file = "rpds_py-0.28.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1a4c6b05c685c0c03f80dabaeb73e74218c49deea965ca63f76a752807397207"}, + {file = "rpds_py-0.28.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4794c6c3fbe8f9ac87699b131a1f26e7b4abcf6d828da46a3a52648c7930eba"}, + {file = "rpds_py-0.28.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2e8456b6ee5527112ff2354dd9087b030e3429e43a74f480d4a5ca79d269fd85"}, + {file = "rpds_py-0.28.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:beb880a9ca0a117415f241f66d56025c02037f7c4efc6fe59b5b8454f1eaa50d"}, + {file = "rpds_py-0.28.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6897bebb118c44b38c9cb62a178e09f1593c949391b9a1a6fe777ccab5934ee7"}, + {file = "rpds_py-0.28.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1b553dd06e875249fd43efd727785efb57a53180e0fde321468222eabbeaafa"}, + {file = "rpds_py-0.28.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:f0b2044fdddeea5b05df832e50d2a06fe61023acb44d76978e1b060206a8a476"}, + {file = "rpds_py-0.28.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05cf1e74900e8da73fa08cc76c74a03345e5a3e37691d07cfe2092d7d8e27b04"}, + {file = "rpds_py-0.28.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:efd489fec7c311dae25e94fe7eeda4b3d06be71c68f2cf2e8ef990ffcd2cd7e8"}, + {file = "rpds_py-0.28.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:ada7754a10faacd4f26067e62de52d6af93b6d9542f0df73c57b9771eb3ba9c4"}, + {file = "rpds_py-0.28.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c2a34fd26588949e1e7977cfcbb17a9a42c948c100cab890c6d8d823f0586457"}, + {file = "rpds_py-0.28.0-cp310-cp310-win32.whl", hash = "sha256:f9174471d6920cbc5e82a7822de8dfd4dcea86eb828b04fc8c6519a77b0ee51e"}, + {file = "rpds_py-0.28.0-cp310-cp310-win_amd64.whl", hash = "sha256:6e32dd207e2c4f8475257a3540ab8a93eff997abfa0a3fdb287cae0d6cd874b8"}, + {file = "rpds_py-0.28.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:03065002fd2e287725d95fbc69688e0c6daf6c6314ba38bdbaa3895418e09296"}, + {file = "rpds_py-0.28.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:28ea02215f262b6d078daec0b45344c89e161eab9526b0d898221d96fdda5f27"}, + {file = "rpds_py-0.28.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25dbade8fbf30bcc551cb352376c0ad64b067e4fc56f90e22ba70c3ce205988c"}, + {file = "rpds_py-0.28.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3c03002f54cc855860bfdc3442928ffdca9081e73b5b382ed0b9e8efe6e5e205"}, + {file = "rpds_py-0.28.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b9699fa7990368b22032baf2b2dce1f634388e4ffc03dfefaaac79f4695edc95"}, + {file = "rpds_py-0.28.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9b06fe1a75e05e0713f06ea0c89ecb6452210fd60e2f1b6ddc1067b990e08d9"}, + {file = "rpds_py-0.28.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac9f83e7b326a3f9ec3ef84cda98fb0a74c7159f33e692032233046e7fd15da2"}, + {file = "rpds_py-0.28.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:0d3259ea9ad8743a75a43eb7819324cdab393263c91be86e2d1901ee65c314e0"}, + {file = "rpds_py-0.28.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9a7548b345f66f6695943b4ef6afe33ccd3f1b638bd9afd0f730dd255c249c9e"}, + {file = "rpds_py-0.28.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c9a40040aa388b037eb39416710fbcce9443498d2eaab0b9b45ae988b53f5c67"}, + {file = "rpds_py-0.28.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8f60c7ea34e78c199acd0d3cda37a99be2c861dd2b8cf67399784f70c9f8e57d"}, + {file = "rpds_py-0.28.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1571ae4292649100d743b26d5f9c63503bb1fedf538a8f29a98dce2d5ba6b4e6"}, + {file = "rpds_py-0.28.0-cp311-cp311-win32.whl", hash = "sha256:5cfa9af45e7c1140af7321fa0bef25b386ee9faa8928c80dc3a5360971a29e8c"}, + {file = "rpds_py-0.28.0-cp311-cp311-win_amd64.whl", hash = "sha256:dd8d86b5d29d1b74100982424ba53e56033dc47720a6de9ba0259cf81d7cecaa"}, + {file = "rpds_py-0.28.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e27d3a5709cc2b3e013bf93679a849213c79ae0573f9b894b284b55e729e120"}, + {file = "rpds_py-0.28.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6b4f28583a4f247ff60cd7bdda83db8c3f5b05a7a82ff20dd4b078571747708f"}, + {file = "rpds_py-0.28.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d678e91b610c29c4b3d52a2c148b641df2b4676ffe47c59f6388d58b99cdc424"}, + {file = "rpds_py-0.28.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e819e0e37a44a78e1383bf1970076e2ccc4dc8c2bbaa2f9bd1dc987e9afff628"}, + {file = "rpds_py-0.28.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5ee514e0f0523db5d3fb171f397c54875dbbd69760a414dccf9d4d7ad628b5bd"}, + {file = "rpds_py-0.28.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3fa06d27fdcee47f07a39e02862da0100cb4982508f5ead53ec533cd5fe55e"}, + {file = "rpds_py-0.28.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:46959ef2e64f9e4a41fc89aa20dbca2b85531f9a72c21099a3360f35d10b0d5a"}, + {file = "rpds_py-0.28.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8455933b4bcd6e83fde3fefc987a023389c4b13f9a58c8d23e4b3f6d13f78c84"}, + {file = "rpds_py-0.28.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:ad50614a02c8c2962feebe6012b52f9802deec4263946cddea37aaf28dd25a66"}, + {file = "rpds_py-0.28.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e5deca01b271492553fdb6c7fd974659dce736a15bae5dad7ab8b93555bceb28"}, + {file = "rpds_py-0.28.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:735f8495a13159ce6a0d533f01e8674cec0c57038c920495f87dcb20b3ddb48a"}, + {file = "rpds_py-0.28.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:961ca621ff10d198bbe6ba4957decca61aa2a0c56695384c1d6b79bf61436df5"}, + {file = "rpds_py-0.28.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2374e16cc9131022e7d9a8f8d65d261d9ba55048c78f3b6e017971a4f5e6353c"}, + {file = "rpds_py-0.28.0-cp312-cp312-win32.whl", hash = "sha256:d15431e334fba488b081d47f30f091e5d03c18527c325386091f31718952fe08"}, + {file = "rpds_py-0.28.0-cp312-cp312-win_amd64.whl", hash = "sha256:a410542d61fc54710f750d3764380b53bf09e8c4edbf2f9141a82aa774a04f7c"}, + {file = "rpds_py-0.28.0-cp312-cp312-win_arm64.whl", hash = "sha256:1f0cfd1c69e2d14f8c892b893997fa9a60d890a0c8a603e88dca4955f26d1edd"}, + {file = "rpds_py-0.28.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e9e184408a0297086f880556b6168fa927d677716f83d3472ea333b42171ee3b"}, + {file = "rpds_py-0.28.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:edd267266a9b0448f33dc465a97cfc5d467594b600fe28e7fa2f36450e03053a"}, + {file = "rpds_py-0.28.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85beb8b3f45e4e32f6802fb6cd6b17f615ef6c6a52f265371fb916fae02814aa"}, + {file = "rpds_py-0.28.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d2412be8d00a1b895f8ad827cc2116455196e20ed994bb704bf138fe91a42724"}, + {file = "rpds_py-0.28.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cf128350d384b777da0e68796afdcebc2e9f63f0e9f242217754e647f6d32491"}, + {file = "rpds_py-0.28.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a2036d09b363aa36695d1cc1a97b36865597f4478470b0697b5ee9403f4fe399"}, + {file = "rpds_py-0.28.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8e1e9be4fa6305a16be628959188e4fd5cd6f1b0e724d63c6d8b2a8adf74ea6"}, + {file = "rpds_py-0.28.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0a403460c9dd91a7f23fc3188de6d8977f1d9603a351d5db6cf20aaea95b538d"}, + {file = "rpds_py-0.28.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d7366b6553cdc805abcc512b849a519167db8f5e5c3472010cd1228b224265cb"}, + {file = "rpds_py-0.28.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b43c6a3726efd50f18d8120ec0551241c38785b68952d240c45ea553912ac41"}, + {file = "rpds_py-0.28.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:0cb7203c7bc69d7c1585ebb33a2e6074492d2fc21ad28a7b9d40457ac2a51ab7"}, + {file = "rpds_py-0.28.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a52a5169c664dfb495882adc75c304ae1d50df552fbd68e100fdc719dee4ff9"}, + {file = "rpds_py-0.28.0-cp313-cp313-win32.whl", hash = "sha256:2e42456917b6687215b3e606ab46aa6bca040c77af7df9a08a6dcfe8a4d10ca5"}, + {file = "rpds_py-0.28.0-cp313-cp313-win_amd64.whl", hash = "sha256:e0a0311caedc8069d68fc2bf4c9019b58a2d5ce3cd7cb656c845f1615b577e1e"}, + {file = "rpds_py-0.28.0-cp313-cp313-win_arm64.whl", hash = "sha256:04c1b207ab8b581108801528d59ad80aa83bb170b35b0ddffb29c20e411acdc1"}, + {file = "rpds_py-0.28.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:f296ea3054e11fc58ad42e850e8b75c62d9a93a9f981ad04b2e5ae7d2186ff9c"}, + {file = "rpds_py-0.28.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5a7306c19b19005ad98468fcefeb7100b19c79fc23a5f24a12e06d91181193fa"}, + {file = "rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e5d9b86aa501fed9862a443c5c3116f6ead8bc9296185f369277c42542bd646b"}, + {file = "rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e5bbc701eff140ba0e872691d573b3d5d30059ea26e5785acba9132d10c8c31d"}, + {file = "rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a5690671cd672a45aa8616d7374fdf334a1b9c04a0cac3c854b1136e92374fe"}, + {file = "rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9f1d92ecea4fa12f978a367c32a5375a1982834649cdb96539dcdc12e609ab1a"}, + {file = "rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d252db6b1a78d0a3928b6190156042d54c93660ce4d98290d7b16b5296fb7cc"}, + {file = "rpds_py-0.28.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:d61b355c3275acb825f8777d6c4505f42b5007e357af500939d4a35b19177259"}, + {file = "rpds_py-0.28.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:acbe5e8b1026c0c580d0321c8aae4b0a1e1676861d48d6e8c6586625055b606a"}, + {file = "rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8aa23b6f0fc59b85b4c7d89ba2965af274346f738e8d9fc2455763602e62fd5f"}, + {file = "rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7b14b0c680286958817c22d76fcbca4800ddacef6f678f3a7c79a1fe7067fe37"}, + {file = "rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:bcf1d210dfee61a6c86551d67ee1031899c0fdbae88b2d44a569995d43797712"}, + {file = "rpds_py-0.28.0-cp313-cp313t-win32.whl", hash = "sha256:3aa4dc0fdab4a7029ac63959a3ccf4ed605fee048ba67ce89ca3168da34a1342"}, + {file = "rpds_py-0.28.0-cp313-cp313t-win_amd64.whl", hash = "sha256:7b7d9d83c942855e4fdcfa75d4f96f6b9e272d42fffcb72cd4bb2577db2e2907"}, + {file = "rpds_py-0.28.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:dcdcb890b3ada98a03f9f2bb108489cdc7580176cb73b4f2d789e9a1dac1d472"}, + {file = "rpds_py-0.28.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f274f56a926ba2dc02976ca5b11c32855cbd5925534e57cfe1fda64e04d1add2"}, + {file = "rpds_py-0.28.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fe0438ac4a29a520ea94c8c7f1754cdd8feb1bc490dfda1bfd990072363d527"}, + {file = "rpds_py-0.28.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8a358a32dd3ae50e933347889b6af9a1bdf207ba5d1a3f34e1a38cd3540e6733"}, + {file = "rpds_py-0.28.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e80848a71c78aa328fefaba9c244d588a342c8e03bda518447b624ea64d1ff56"}, + {file = "rpds_py-0.28.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f586db2e209d54fe177e58e0bc4946bea5fb0102f150b1b2f13de03e1f0976f8"}, + {file = "rpds_py-0.28.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ae8ee156d6b586e4292491e885d41483136ab994e719a13458055bec14cf370"}, + {file = "rpds_py-0.28.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:a805e9b3973f7e27f7cab63a6b4f61d90f2e5557cff73b6e97cd5b8540276d3d"}, + {file = "rpds_py-0.28.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5d3fd16b6dc89c73a4da0b4ac8b12a7ecc75b2864b95c9e5afed8003cb50a728"}, + {file = "rpds_py-0.28.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6796079e5d24fdaba6d49bda28e2c47347e89834678f2bc2c1b4fc1489c0fb01"}, + {file = "rpds_py-0.28.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:76500820c2af232435cbe215e3324c75b950a027134e044423f59f5b9a1ba515"}, + {file = "rpds_py-0.28.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bbdc5640900a7dbf9dd707fe6388972f5bbd883633eb68b76591044cfe346f7e"}, + {file = "rpds_py-0.28.0-cp314-cp314-win32.whl", hash = "sha256:adc8aa88486857d2b35d75f0640b949759f79dc105f50aa2c27816b2e0dd749f"}, + {file = "rpds_py-0.28.0-cp314-cp314-win_amd64.whl", hash = "sha256:66e6fa8e075b58946e76a78e69e1a124a21d9a48a5b4766d15ba5b06869d1fa1"}, + {file = "rpds_py-0.28.0-cp314-cp314-win_arm64.whl", hash = "sha256:a6fe887c2c5c59413353b7c0caff25d0e566623501ccfff88957fa438a69377d"}, + {file = "rpds_py-0.28.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7a69df082db13c7070f7b8b1f155fa9e687f1d6aefb7b0e3f7231653b79a067b"}, + {file = "rpds_py-0.28.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b1cde22f2c30ebb049a9e74c5374994157b9b70a16147d332f89c99c5960737a"}, + {file = "rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5338742f6ba7a51012ea470bd4dc600a8c713c0c72adaa0977a1b1f4327d6592"}, + {file = "rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e1460ebde1bcf6d496d80b191d854adedcc619f84ff17dc1c6d550f58c9efbba"}, + {file = "rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e3eb248f2feba84c692579257a043a7699e28a77d86c77b032c1d9fbb3f0219c"}, + {file = "rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3bbba5def70b16cd1c1d7255666aad3b290fbf8d0fe7f9f91abafb73611a91"}, + {file = "rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3114f4db69ac5a1f32e7e4d1cbbe7c8f9cf8217f78e6e002cedf2d54c2a548ed"}, + {file = "rpds_py-0.28.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4b0cb8a906b1a0196b863d460c0222fb8ad0f34041568da5620f9799b83ccf0b"}, + {file = "rpds_py-0.28.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cf681ac76a60b667106141e11a92a3330890257e6f559ca995fbb5265160b56e"}, + {file = "rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1e8ee6413cfc677ce8898d9cde18cc3a60fc2ba756b0dec5b71eb6eb21c49fa1"}, + {file = "rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b3072b16904d0b5572a15eb9d31c1954e0d3227a585fc1351aa9878729099d6c"}, + {file = "rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b670c30fd87a6aec281c3c9896d3bae4b205fd75d79d06dc87c2503717e46092"}, + {file = "rpds_py-0.28.0-cp314-cp314t-win32.whl", hash = "sha256:8014045a15b4d2b3476f0a287fcc93d4f823472d7d1308d47884ecac9e612be3"}, + {file = "rpds_py-0.28.0-cp314-cp314t-win_amd64.whl", hash = "sha256:7a4e59c90d9c27c561eb3160323634a9ff50b04e4f7820600a2beb0ac90db578"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f5e7101145427087e493b9c9b959da68d357c28c562792300dd21a095118ed16"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:31eb671150b9c62409a888850aaa8e6533635704fe2b78335f9aaf7ff81eec4d"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48b55c1f64482f7d8bd39942f376bfdf2f6aec637ee8c805b5041e14eeb771db"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:24743a7b372e9a76171f6b69c01aedf927e8ac3e16c474d9fe20d552a8cb45c7"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:389c29045ee8bbb1627ea190b4976a310a295559eaf9f1464a1a6f2bf84dde78"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:23690b5827e643150cf7b49569679ec13fe9a610a15949ed48b85eb7f98f34ec"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f0c9266c26580e7243ad0d72fc3e01d6b33866cfab5084a6da7576bcf1c4f72"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:4c6c4db5d73d179746951486df97fd25e92396be07fc29ee8ff9a8f5afbdfb27"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a3b695a8fa799dd2cfdb4804b37096c5f6dba1ac7f48a7fbf6d0485bcd060316"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:6aa1bfce3f83baf00d9c5fcdbba93a3ab79958b4c7d7d1f55e7fe68c20e63912"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:7b0f9dceb221792b3ee6acb5438eb1f02b0cb2c247796a72b016dcc92c6de829"}, + {file = "rpds_py-0.28.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:5d0145edba8abd3db0ab22b5300c99dc152f5c9021fab861be0f0544dc3cbc5f"}, + {file = "rpds_py-0.28.0.tar.gz", hash = "sha256:abd4df20485a0983e2ca334a216249b6186d6e3c1627e106651943dbdb791aea"}, ] [[package]] @@ -2987,6 +3862,7 @@ description = "Fundamental algorithms for scientific computing in Python" optional = false python-versions = ">=3.9" groups = ["main"] +markers = "python_version < \"3.14\"" files = [ {file = "scipy-1.13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:20335853b85e9a49ff7572ab453794298bcf0354d8068c5f6775a0eabf350aca"}, {file = "scipy-1.13.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f"}, @@ -3023,6 +3899,86 @@ dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pyde doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.12.0)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] +[[package]] +name = "scipy" +version = "1.16.3" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = ">=3.11" +groups = ["main"] +markers = "python_version >= \"3.14\"" +files = [ + {file = "scipy-1.16.3-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:40be6cf99e68b6c4321e9f8782e7d5ff8265af28ef2cd56e9c9b2638fa08ad97"}, + {file = "scipy-1.16.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:8be1ca9170fcb6223cc7c27f4305d680ded114a1567c0bd2bfcbf947d1b17511"}, + {file = "scipy-1.16.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bea0a62734d20d67608660f69dcda23e7f90fb4ca20974ab80b6ed40df87a005"}, + {file = "scipy-1.16.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:2a207a6ce9c24f1951241f4693ede2d393f59c07abc159b2cb2be980820e01fb"}, + {file = "scipy-1.16.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:532fb5ad6a87e9e9cd9c959b106b73145a03f04c7d57ea3e6f6bb60b86ab0876"}, + {file = "scipy-1.16.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0151a0749efeaaab78711c78422d413c583b8cdd2011a3c1d6c794938ee9fdb2"}, + {file = "scipy-1.16.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b7180967113560cca57418a7bc719e30366b47959dd845a93206fbed693c867e"}, + {file = "scipy-1.16.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:deb3841c925eeddb6afc1e4e4a45e418d19ec7b87c5df177695224078e8ec733"}, + {file = "scipy-1.16.3-cp311-cp311-win_amd64.whl", hash = "sha256:53c3844d527213631e886621df5695d35e4f6a75f620dca412bcd292f6b87d78"}, + {file = "scipy-1.16.3-cp311-cp311-win_arm64.whl", hash = "sha256:9452781bd879b14b6f055b26643703551320aa8d79ae064a71df55c00286a184"}, + {file = "scipy-1.16.3-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:81fc5827606858cf71446a5e98715ba0e11f0dbc83d71c7409d05486592a45d6"}, + {file = "scipy-1.16.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:c97176013d404c7346bf57874eaac5187d969293bf40497140b0a2b2b7482e07"}, + {file = "scipy-1.16.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2b71d93c8a9936046866acebc915e2af2e292b883ed6e2cbe5c34beb094b82d9"}, + {file = "scipy-1.16.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3d4a07a8e785d80289dfe66b7c27d8634a773020742ec7187b85ccc4b0e7b686"}, + {file = "scipy-1.16.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0553371015692a898e1aa858fed67a3576c34edefa6b7ebdb4e9dde49ce5c203"}, + {file = "scipy-1.16.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:72d1717fd3b5e6ec747327ce9bda32d5463f472c9dce9f54499e81fbd50245a1"}, + {file = "scipy-1.16.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fb2472e72e24d1530debe6ae078db70fb1605350c88a3d14bc401d6306dbffe"}, + {file = "scipy-1.16.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5192722cffe15f9329a3948c4b1db789fbb1f05c97899187dcf009b283aea70"}, + {file = "scipy-1.16.3-cp312-cp312-win_amd64.whl", hash = "sha256:56edc65510d1331dae01ef9b658d428e33ed48b4f77b1d51caf479a0253f96dc"}, + {file = "scipy-1.16.3-cp312-cp312-win_arm64.whl", hash = "sha256:a8a26c78ef223d3e30920ef759e25625a0ecdd0d60e5a8818b7513c3e5384cf2"}, + {file = "scipy-1.16.3-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:d2ec56337675e61b312179a1ad124f5f570c00f920cc75e1000025451b88241c"}, + {file = "scipy-1.16.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:16b8bc35a4cc24db80a0ec836a9286d0e31b2503cb2fd7ff7fb0e0374a97081d"}, + {file = "scipy-1.16.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:5803c5fadd29de0cf27fa08ccbfe7a9e5d741bf63e4ab1085437266f12460ff9"}, + {file = "scipy-1.16.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:b81c27fc41954319a943d43b20e07c40bdcd3ff7cf013f4fb86286faefe546c4"}, + {file = "scipy-1.16.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0c3b4dd3d9b08dbce0f3440032c52e9e2ab9f96ade2d3943313dfe51a7056959"}, + {file = "scipy-1.16.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7dc1360c06535ea6116a2220f760ae572db9f661aba2d88074fe30ec2aa1ff88"}, + {file = "scipy-1.16.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:663b8d66a8748051c3ee9c96465fb417509315b99c71550fda2591d7dd634234"}, + {file = "scipy-1.16.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eab43fae33a0c39006a88096cd7b4f4ef545ea0447d250d5ac18202d40b6611d"}, + {file = "scipy-1.16.3-cp313-cp313-win_amd64.whl", hash = "sha256:062246acacbe9f8210de8e751b16fc37458213f124bef161a5a02c7a39284304"}, + {file = "scipy-1.16.3-cp313-cp313-win_arm64.whl", hash = "sha256:50a3dbf286dbc7d84f176f9a1574c705f277cb6565069f88f60db9eafdbe3ee2"}, + {file = "scipy-1.16.3-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:fb4b29f4cf8cc5a8d628bc8d8e26d12d7278cd1f219f22698a378c3d67db5e4b"}, + {file = "scipy-1.16.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:8d09d72dc92742988b0e7750bddb8060b0c7079606c0d24a8cc8e9c9c11f9079"}, + {file = "scipy-1.16.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:03192a35e661470197556de24e7cb1330d84b35b94ead65c46ad6f16f6b28f2a"}, + {file = "scipy-1.16.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:57d01cb6f85e34f0946b33caa66e892aae072b64b034183f3d87c4025802a119"}, + {file = "scipy-1.16.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:96491a6a54e995f00a28a3c3badfff58fd093bf26cd5fb34a2188c8c756a3a2c"}, + {file = "scipy-1.16.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cd13e354df9938598af2be05822c323e97132d5e6306b83a3b4ee6724c6e522e"}, + {file = "scipy-1.16.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63d3cdacb8a824a295191a723ee5e4ea7768ca5ca5f2838532d9f2e2b3ce2135"}, + {file = "scipy-1.16.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e7efa2681ea410b10dde31a52b18b0154d66f2485328830e45fdf183af5aefc6"}, + {file = "scipy-1.16.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2d1ae2cf0c350e7705168ff2429962a89ad90c2d49d1dd300686d8b2a5af22fc"}, + {file = "scipy-1.16.3-cp313-cp313t-win_arm64.whl", hash = "sha256:0c623a54f7b79dd88ef56da19bc2873afec9673a48f3b85b18e4d402bdd29a5a"}, + {file = "scipy-1.16.3-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:875555ce62743e1d54f06cdf22c1e0bc47b91130ac40fe5d783b6dfa114beeb6"}, + {file = "scipy-1.16.3-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:bb61878c18a470021fb515a843dc7a76961a8daceaaaa8bad1332f1bf4b54657"}, + {file = "scipy-1.16.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f2622206f5559784fa5c4b53a950c3c7c1cf3e84ca1b9c4b6c03f062f289ca26"}, + {file = "scipy-1.16.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7f68154688c515cdb541a31ef8eb66d8cd1050605be9dcd74199cbd22ac739bc"}, + {file = "scipy-1.16.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3c820ddb80029fe9f43d61b81d8b488d3ef8ca010d15122b152db77dc94c22"}, + {file = "scipy-1.16.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d3837938ae715fc0fe3c39c0202de3a8853aff22ca66781ddc2ade7554b7e2cc"}, + {file = "scipy-1.16.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aadd23f98f9cb069b3bd64ddc900c4d277778242e961751f77a8cb5c4b946fb0"}, + {file = "scipy-1.16.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b7c5f1bda1354d6a19bc6af73a649f8285ca63ac6b52e64e658a5a11d4d69800"}, + {file = "scipy-1.16.3-cp314-cp314-win_amd64.whl", hash = "sha256:e5d42a9472e7579e473879a1990327830493a7047506d58d73fc429b84c1d49d"}, + {file = "scipy-1.16.3-cp314-cp314-win_arm64.whl", hash = "sha256:6020470b9d00245926f2d5bb93b119ca0340f0d564eb6fbaad843eaebf9d690f"}, + {file = "scipy-1.16.3-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:e1d27cbcb4602680a49d787d90664fa4974063ac9d4134813332a8c53dbe667c"}, + {file = "scipy-1.16.3-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:9b9c9c07b6d56a35777a1b4cc8966118fb16cfd8daf6743867d17d36cfad2d40"}, + {file = "scipy-1.16.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:3a4c460301fb2cffb7f88528f30b3127742cff583603aa7dc964a52c463b385d"}, + {file = "scipy-1.16.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f667a4542cc8917af1db06366d3f78a5c8e83badd56409f94d1eac8d8d9133fa"}, + {file = "scipy-1.16.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f379b54b77a597aa7ee5e697df0d66903e41b9c85a6dd7946159e356319158e8"}, + {file = "scipy-1.16.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4aff59800a3b7f786b70bfd6ab551001cb553244988d7d6b8299cb1ea653b353"}, + {file = "scipy-1.16.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:da7763f55885045036fabcebd80144b757d3db06ab0861415d1c3b7c69042146"}, + {file = "scipy-1.16.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ffa6eea95283b2b8079b821dc11f50a17d0571c92b43e2b5b12764dc5f9b285d"}, + {file = "scipy-1.16.3-cp314-cp314t-win_amd64.whl", hash = "sha256:d9f48cafc7ce94cf9b15c6bffdc443a81a27bf7075cf2dcd5c8b40f85d10c4e7"}, + {file = "scipy-1.16.3-cp314-cp314t-win_arm64.whl", hash = "sha256:21d9d6b197227a12dcbf9633320a4e34c6b0e51c57268df255a0942983bac562"}, + {file = "scipy-1.16.3.tar.gz", hash = "sha256:01e87659402762f43bd2fee13370553a17ada367d42e7487800bf2916535aecb"}, +] + +[package.dependencies] +numpy = ">=1.25.2,<2.6" + +[package.extras] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy (==1.10.0)", "pycodestyle", "pydevtool", "rich-click", "ruff (>=0.0.292)", "types-psutil", "typing_extensions"] +doc = ["intersphinx_registry", "jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.19.1)", "jupytext", "linkify-it-py", "matplotlib (>=3.5)", "myst-nb (>=1.2.0)", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0,<8.2.0)", "sphinx-copybutton", "sphinx-design (>=0.4.0)"] +test = ["Cython", "array-api-strict (>=2.3.1)", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja ; sys_platform != \"emscripten\"", "pooch", "pytest (>=8.0.0)", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + [[package]] name = "send2trash" version = "1.8.3" @@ -3091,15 +4047,15 @@ files = [ [[package]] name = "soupsieve" -version = "2.7" +version = "2.8" description = "A modern CSS selector implementation for Beautiful Soup." optional = true -python-versions = ">=3.8" +python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4"}, - {file = "soupsieve-2.7.tar.gz", hash = "sha256:ad282f9b6926286d2ead4750552c8a6142bc4c783fd66b0293547c8fe6ae126a"}, + {file = "soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c"}, + {file = "soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f"}, ] [[package]] @@ -3168,68 +4124,78 @@ test = ["pytest", "ruff"] [[package]] name = "tomli" -version = "2.2.1" +version = "2.3.0" description = "A lil' TOML parser" optional = true python-versions = ">=3.8" groups = ["main"] markers = "extra == \"dev\" and python_version < \"3.11\"" files = [ - {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"}, - {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"}, - {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"}, - {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"}, - {file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"}, - {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"}, - {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"}, - {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"}, - {file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"}, - {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"}, - {file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"}, - {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"}, - {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"}, - {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"}, - {file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"}, - {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"}, - {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"}, - {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"}, - {file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"}, - {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"}, - {file = "tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7"}, - {file = "tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c"}, - {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13"}, - {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281"}, - {file = "tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272"}, - {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140"}, - {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2"}, - {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744"}, - {file = "tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec"}, - {file = "tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69"}, - {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, - {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, + {file = "tomli-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:88bd15eb972f3664f5ed4b57c1634a97153b4bac4479dcb6a495f41921eb7f45"}, + {file = "tomli-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:883b1c0d6398a6a9d29b508c331fa56adbcdff647f6ace4dfca0f50e90dfd0ba"}, + {file = "tomli-2.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d1381caf13ab9f300e30dd8feadb3de072aeb86f1d34a8569453ff32a7dea4bf"}, + {file = "tomli-2.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0e285d2649b78c0d9027570d4da3425bdb49830a6156121360b3f8511ea3441"}, + {file = "tomli-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a154a9ae14bfcf5d8917a59b51ffd5a3ac1fd149b71b47a3a104ca4edcfa845"}, + {file = "tomli-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:74bf8464ff93e413514fefd2be591c3b0b23231a77f901db1eb30d6f712fc42c"}, + {file = "tomli-2.3.0-cp311-cp311-win32.whl", hash = "sha256:00b5f5d95bbfc7d12f91ad8c593a1659b6387b43f054104cda404be6bda62456"}, + {file = "tomli-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:4dc4ce8483a5d429ab602f111a93a6ab1ed425eae3122032db7e9acf449451be"}, + {file = "tomli-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d7d86942e56ded512a594786a5ba0a5e521d02529b3826e7761a05138341a2ac"}, + {file = "tomli-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:73ee0b47d4dad1c5e996e3cd33b8a76a50167ae5f96a2607cbe8cc773506ab22"}, + {file = "tomli-2.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:792262b94d5d0a466afb5bc63c7daa9d75520110971ee269152083270998316f"}, + {file = "tomli-2.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f195fe57ecceac95a66a75ac24d9d5fbc98ef0962e09b2eddec5d39375aae52"}, + {file = "tomli-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e31d432427dcbf4d86958c184b9bfd1e96b5b71f8eb17e6d02531f434fd335b8"}, + {file = "tomli-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b0882799624980785240ab732537fcfc372601015c00f7fc367c55308c186f6"}, + {file = "tomli-2.3.0-cp312-cp312-win32.whl", hash = "sha256:ff72b71b5d10d22ecb084d345fc26f42b5143c5533db5e2eaba7d2d335358876"}, + {file = "tomli-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:1cb4ed918939151a03f33d4242ccd0aa5f11b3547d0cf30f7c74a408a5b99878"}, + {file = "tomli-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5192f562738228945d7b13d4930baffda67b69425a7f0da96d360b0a3888136b"}, + {file = "tomli-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:be71c93a63d738597996be9528f4abe628d1adf5e6eb11607bc8fe1a510b5dae"}, + {file = "tomli-2.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4665508bcbac83a31ff8ab08f424b665200c0e1e645d2bd9ab3d3e557b6185b"}, + {file = "tomli-2.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4021923f97266babc6ccab9f5068642a0095faa0a51a246a6a02fccbb3514eaf"}, + {file = "tomli-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4ea38c40145a357d513bffad0ed869f13c1773716cf71ccaa83b0fa0cc4e42f"}, + {file = "tomli-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ad805ea85eda330dbad64c7ea7a4556259665bdf9d2672f5dccc740eb9d3ca05"}, + {file = "tomli-2.3.0-cp313-cp313-win32.whl", hash = "sha256:97d5eec30149fd3294270e889b4234023f2c69747e555a27bd708828353ab606"}, + {file = "tomli-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0c95ca56fbe89e065c6ead5b593ee64b84a26fca063b5d71a1122bf26e533999"}, + {file = "tomli-2.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cebc6fe843e0733ee827a282aca4999b596241195f43b4cc371d64fc6639da9e"}, + {file = "tomli-2.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4c2ef0244c75aba9355561272009d934953817c49f47d768070c3c94355c2aa3"}, + {file = "tomli-2.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c22a8bf253bacc0cf11f35ad9808b6cb75ada2631c2d97c971122583b129afbc"}, + {file = "tomli-2.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0eea8cc5c5e9f89c9b90c4896a8deefc74f518db5927d0e0e8d4a80953d774d0"}, + {file = "tomli-2.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b74a0e59ec5d15127acdabd75ea17726ac4c5178ae51b85bfe39c4f8a278e879"}, + {file = "tomli-2.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b5870b50c9db823c595983571d1296a6ff3e1b88f734a4c8f6fc6188397de005"}, + {file = "tomli-2.3.0-cp314-cp314-win32.whl", hash = "sha256:feb0dacc61170ed7ab602d3d972a58f14ee3ee60494292d384649a3dc38ef463"}, + {file = "tomli-2.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:b273fcbd7fc64dc3600c098e39136522650c49bca95df2d11cf3b626422392c8"}, + {file = "tomli-2.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:940d56ee0410fa17ee1f12b817b37a4d4e4dc4d27340863cc67236c74f582e77"}, + {file = "tomli-2.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f85209946d1fe94416debbb88d00eb92ce9cd5266775424ff81bc959e001acaf"}, + {file = "tomli-2.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a56212bdcce682e56b0aaf79e869ba5d15a6163f88d5451cbde388d48b13f530"}, + {file = "tomli-2.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5f3ffd1e098dfc032d4d3af5c0ac64f6d286d98bc148698356847b80fa4de1b"}, + {file = "tomli-2.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e01decd096b1530d97d5d85cb4dff4af2d8347bd35686654a004f8dea20fc67"}, + {file = "tomli-2.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8a35dd0e643bb2610f156cca8db95d213a90015c11fee76c946aa62b7ae7e02f"}, + {file = "tomli-2.3.0-cp314-cp314t-win32.whl", hash = "sha256:a1f7f282fe248311650081faafa5f4732bdbfef5d45fe3f2e702fbc6f2d496e0"}, + {file = "tomli-2.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:70a251f8d4ba2d9ac2542eecf008b3c8a9fc5c3f9f02c56a9d7952612be2fdba"}, + {file = "tomli-2.3.0-py3-none-any.whl", hash = "sha256:e95b1af3c5b07d9e643909b5abbec77cd9f1217e6d0bca72b0234736b9fb1f1b"}, + {file = "tomli-2.3.0.tar.gz", hash = "sha256:64be704a875d2a59753d80ee8a533c3fe183e3f06807ff7dc2232938ccb01549"}, ] [[package]] name = "tornado" -version = "6.5.1" +version = "6.5.2" description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "tornado-6.5.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d50065ba7fd11d3bd41bcad0825227cc9a95154bad83239357094c36708001f7"}, - {file = "tornado-6.5.1-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9e9ca370f717997cb85606d074b0e5b247282cf5e2e1611568b8821afe0342d6"}, - {file = "tornado-6.5.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b77e9dfa7ed69754a54c89d82ef746398be82f749df69c4d3abe75c4d1ff4888"}, - {file = "tornado-6.5.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:253b76040ee3bab8bcf7ba9feb136436a3787208717a1fb9f2c16b744fba7331"}, - {file = "tornado-6.5.1-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:308473f4cc5a76227157cdf904de33ac268af770b2c5f05ca6c1161d82fdd95e"}, - {file = "tornado-6.5.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:caec6314ce8a81cf69bd89909f4b633b9f523834dc1a352021775d45e51d9401"}, - {file = "tornado-6.5.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:13ce6e3396c24e2808774741331638ee6c2f50b114b97a55c5b442df65fd9692"}, - {file = "tornado-6.5.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5cae6145f4cdf5ab24744526cc0f55a17d76f02c98f4cff9daa08ae9a217448a"}, - {file = "tornado-6.5.1-cp39-abi3-win32.whl", hash = "sha256:e0a36e1bc684dca10b1aa75a31df8bdfed656831489bc1e6a6ebed05dc1ec365"}, - {file = "tornado-6.5.1-cp39-abi3-win_amd64.whl", hash = "sha256:908e7d64567cecd4c2b458075589a775063453aeb1d2a1853eedb806922f568b"}, - {file = "tornado-6.5.1-cp39-abi3-win_arm64.whl", hash = "sha256:02420a0eb7bf617257b9935e2b754d1b63897525d8a289c9d65690d580b4dcf7"}, - {file = "tornado-6.5.1.tar.gz", hash = "sha256:84ceece391e8eb9b2b95578db65e920d2a61070260594819589609ba9bc6308c"}, + {file = "tornado-6.5.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2436822940d37cde62771cff8774f4f00b3c8024fe482e16ca8387b8a2724db6"}, + {file = "tornado-6.5.2-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:583a52c7aa94ee046854ba81d9ebb6c81ec0fd30386d96f7640c96dad45a03ef"}, + {file = "tornado-6.5.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0fe179f28d597deab2842b86ed4060deec7388f1fd9c1b4a41adf8af058907e"}, + {file = "tornado-6.5.2-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b186e85d1e3536d69583d2298423744740986018e393d0321df7340e71898882"}, + {file = "tornado-6.5.2-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e792706668c87709709c18b353da1f7662317b563ff69f00bab83595940c7108"}, + {file = "tornado-6.5.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:06ceb1300fd70cb20e43b1ad8aaee0266e69e7ced38fa910ad2e03285009ce7c"}, + {file = "tornado-6.5.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:74db443e0f5251be86cbf37929f84d8c20c27a355dd452a5cfa2aada0d001ec4"}, + {file = "tornado-6.5.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b5e735ab2889d7ed33b32a459cac490eda71a1ba6857b0118de476ab6c366c04"}, + {file = "tornado-6.5.2-cp39-abi3-win32.whl", hash = "sha256:c6f29e94d9b37a95013bb669616352ddb82e3bfe8326fccee50583caebc8a5f0"}, + {file = "tornado-6.5.2-cp39-abi3-win_amd64.whl", hash = "sha256:e56a5af51cc30dd2cae649429af65ca2f6571da29504a07995175df14c18f35f"}, + {file = "tornado-6.5.2-cp39-abi3-win_arm64.whl", hash = "sha256:d6c33dc3672e3a1f3618eb63b7ef4683a7688e7b9e6e8f0d9aa5726360a004af"}, + {file = "tornado-6.5.2.tar.gz", hash = "sha256:ab53c8f9a0fa351e2c0741284e06c7a45da86afb544133201c5cc8578eb076a0"}, ] [[package]] @@ -3272,34 +4238,34 @@ docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] [[package]] -name = "types-python-dateutil" -version = "2.9.0.20250708" -description = "Typing stubs for python-dateutil" +name = "typing-extensions" +version = "4.15.0" +description = "Backported and Experimental Type Hints for Python 3.9+" optional = true python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "types_python_dateutil-2.9.0.20250708-py3-none-any.whl", hash = "sha256:4d6d0cc1cc4d24a2dc3816024e502564094497b713f7befda4d5bc7a8e3fd21f"}, - {file = "types_python_dateutil-2.9.0.20250708.tar.gz", hash = "sha256:ccdbd75dab2d6c9696c350579f34cffe2c281e4c5f27a585b2a2438dd1d5c8ab"}, + {file = "typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"}, + {file = "typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466"}, ] [[package]] -name = "typing-extensions" -version = "4.14.1" -description = "Backported and Experimental Type Hints for Python 3.9+" +name = "tzdata" +version = "2025.2" +description = "Provider of IANA time zone data" optional = true -python-versions = ">=3.9" +python-versions = ">=2" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76"}, - {file = "typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36"}, + {file = "tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8"}, + {file = "tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9"}, ] [[package]] name = "unified-momentum-model" -version = "0.3.0" +version = "0.4.1" description = "" optional = false python-versions = "^3.8" @@ -3323,7 +4289,7 @@ figures = ["dualitic @ git+https://github.com/jaimeliew1/Dualitic.git", "ipykern type = "git" url = "https://github.com/Howland-Lab/Unified-Momentum-Model.git" reference = "HEAD" -resolved_reference = "ebbfd35978a9a0855962501450960ec70b032bf2" +resolved_reference = "e55945a541db1a88d70b34f408dbf26a772f1c2c" [[package]] name = "uri-template" @@ -3362,15 +4328,15 @@ zstd = ["zstandard (>=0.18.0)"] [[package]] name = "wcwidth" -version = "0.2.13" +version = "0.2.14" description = "Measures the displayed width of unicode strings in a terminal" optional = true -python-versions = "*" +python-versions = ">=3.6" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, - {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, + {file = "wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1"}, + {file = "wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605"}, ] [[package]] @@ -3401,21 +4367,21 @@ files = [ [[package]] name = "websocket-client" -version = "1.8.0" +version = "1.9.0" description = "WebSocket client for Python with low level API options" optional = true -python-versions = ">=3.8" +python-versions = ">=3.9" groups = ["main"] markers = "extra == \"dev\"" files = [ - {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, - {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, + {file = "websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef"}, + {file = "websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98"}, ] [package.extras] -docs = ["Sphinx (>=6.0)", "myst-parser (>=2.0.0)", "sphinx-rtd-theme (>=1.1.0)"] +docs = ["Sphinx (>=6.0)", "myst-parser (>=2.0.0)", "sphinx_rtd_theme (>=1.1.0)"] optional = ["python-socks", "wsaccel"] -test = ["websockets"] +test = ["pytest", "websockets"] [[package]] name = "widgetsnbextension" diff --git a/pyproject.toml b/pyproject.toml index 491f33d..d84624e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "mitwindfarm" -version = "1.0.0" +version = "1.1.1" description = "" authors = ["Jaime Liew "] readme = "README.md" diff --git a/tests/test_curled_wake.py b/tests/test_curled_wake.py new file mode 100644 index 0000000..305c0e1 --- /dev/null +++ b/tests/test_curled_wake.py @@ -0,0 +1,115 @@ +from pytest import fixture, mark, approx +import numpy as np +from mitwindfarm import Uniform, Layout +from mitwindfarm.windfarm import Windfarm, CurledWindfarm +from mitwindfarm.Rotor import UnifiedAD_TI, UnifiedAD +from UnifiedMomentumModel.Utilities.Geometry import calc_eff_yaw, eff_yaw_inv_rotation +from scipy.ndimage import rotate + +def get_curled_windfarm(couple_x0 = False, TIamb = 0.05): + base_windfield = Uniform(TIamb=TIamb) + wf_curled = CurledWindfarm( + rotor_model=UnifiedAD_TI(couple_x0 = couple_x0), + base_windfield=base_windfield, + solver_kwargs=dict( + dy=1/10, + dz=1/10, + integrator="scipy_rk23", # see mitwindfarm.utils.integrate + k_model="k-l", # alternatives: "const", "2021" + verbose=False, + ), + ) + + xturb, yturb, zturb = [0], [0], [0] + layout = Layout(xturb, yturb, zturb) + return wf_curled, layout + +def get_gaussian_windfarm(): + base_windfield = Uniform() + wf = Windfarm( + rotor_model=UnifiedAD(), + base_windfield=base_windfield, + ) + return wf + +def get_yaws_tilts(val): + # create three sets of setpoints with same effective angle, one with just yaw, + # one with just tilt, and one with yaw and tilt. + yaw3 = np.radians(val) + tilt3 = np.radians(val) + eff_yaw = calc_eff_yaw(yaw3, tilt3) + yaws, tilts = [eff_yaw, 0, yaw3], [0, eff_yaw, tilt3] + return yaws, tilts + + + +# test that wake is the same stamp rotated for different combinations of yaw and tilt +def test_wake_shape_rotation(): + wf_curled, layout = get_curled_windfarm() + # get grid points + pad, res = 2, 100 + ylim = (np.min(layout.y) - pad, np.max(layout.y) + pad) + zlim = (np.min(layout.z) - pad, np.max(layout.z) + pad) + _y, _z = np.linspace(*ylim, res), np.linspace(*zlim, res) + ymesh, zmesh = np.meshgrid(_y, _z) + # get solutions to all set point combos + wsp_list = [] + ctprime = 1.33 + xval = 5 #D + yaws, tilts = get_yaws_tilts(20) + for yaw, tilt in zip(yaws, tilts): + setpoints = [(ctprime, yaw, tilt)] + sol = wf_curled(layout, setpoints) + wsp = sol.windfield.wsp(np.full_like(ymesh, xval), ymesh, zmesh) + wsp_list.append(wsp) + + # rotate solutions to be in "yaw-only" frame + rotated_yaw = rotate(wsp_list[0], 0, reshape=False, order=1, mode='constant', cval=1) + rotated_tilt = rotate(wsp_list[1], -90, reshape=False, order=1, mode='constant', cval=1) + rotated_yaw_and_tilt = rotate(wsp_list[2], -45, reshape=False, order=1, mode='constant', cval=1) + + # check that there is less than 5% difference between each rotated dataset compared to yaw simulation + assert(np.allclose(rotated_yaw, wsp_list[0], atol = 0.05 * np.min(wsp_list[0]))) + assert(np.allclose(rotated_tilt, wsp_list[0], atol = 0.05 * np.min(wsp_list[0]))) + assert(np.allclose(rotated_yaw_and_tilt, wsp_list[0], atol = 0.05 * np.min(wsp_list[0]))) + +def test_TI_rotor_equivalence(): + wf_curled_TI, layout = get_curled_windfarm(couple_x0 = False, TIamb = 0) + wf_curled_TI_couple, _ = get_curled_windfarm(couple_x0 = True, TIamb = 0) + wf = get_gaussian_windfarm() + yaws, tilts = get_yaws_tilts(20) + ctprime = 1.33 + for yaw, tilt in zip(yaws, tilts): + setpoints = [(ctprime, yaw, tilt)] + sol1 = wf_curled_TI(layout, setpoints) + sol2 = wf_curled_TI_couple(layout, setpoints) + sol3 = wf(layout, setpoints) + # ensure that without TI, the new UMM models (with TI adjustments) are equivalent + assert sol1.rotors[0].u4 == sol2.rotors[0].u4 == sol3.rotors[0].u4 + assert sol1.rotors[0].Cp == sol2.rotors[0].Cp == sol3.rotors[0].Cp + # need to use "is-close" since values are re-calculated and could be off by rounding + assert np.isclose(sol1.rotors[0].extra.dp_NL, sol3.rotors[0].extra.dp_NL) + assert np.isclose(sol1.rotors[0].extra.x0, sol3.rotors[0].extra.x0) + assert sol2.rotors[0].extra.dp_NL == sol3.rotors[0].extra.dp_NL + assert sol2.rotors[0].extra.x0 == sol3.rotors[0].extra.x0 + +def test_TI_rotor_differences(): + wf_curled_TI, layout = get_curled_windfarm(couple_x0 = False, TIamb = 0.1) + wf_curled_TI_couple, _ = get_curled_windfarm(couple_x0 = True, TIamb = 0.1) + wf = get_gaussian_windfarm() + yaws, tilts = get_yaws_tilts(20) + ctprime = 1.33 + for yaw, tilt in zip(yaws, tilts): + setpoints = [(ctprime, yaw, tilt)] + sol1 = wf_curled_TI(layout, setpoints) + sol2 = wf_curled_TI_couple(layout, setpoints) + sol3 = wf(layout, setpoints) + # ensure that with TI, the new UMM models (with TI adjustments) are different + assert sol1.rotors[0].extra.dp_NL != sol3.rotors[0].extra.dp_NL + assert sol2.rotors[0].extra.dp_NL != sol3.rotors[0].extra.dp_NL + assert sol2.rotors[0].u4 != sol3.rotors[0].u4 + +test_wake_shape_rotation() +test_TI_rotor_equivalence() +test_TI_rotor_differences() + \ No newline at end of file diff --git a/tests/test_wake.py b/tests/test_wake.py index c01765b..eec14c3 100644 --- a/tests/test_wake.py +++ b/tests/test_wake.py @@ -2,6 +2,7 @@ import numpy as np from mitwindfarm import RotorSolution, GaussianWakeModel +# helper functions to test tilt @fixture def grid_info(): xturb = 1 @@ -21,11 +22,9 @@ def wake_model_args(): an, u4, REWS = 0.3, 0.5, 1.0 return yaw, tilt, Cp, Ct, Ctprime, an, u4, REWS - +# test that wake follows centerline as provided by v4 and w4 @mark.parametrize('yturb, zturb, v4, w4', [(1, 1, 0, 0), (1, 0, 0.5, 0.0), (0, 1, -0.5, 0.0), (-1, 1, 0, 0.5), (1, -1, 0, -0.5), (-1, -1, 0.5, 0.5), (0, 0, -0.5, 0.5)]) def test_v4_w4_centerline_wake(grid_info, wake_model, wake_model_args, yturb, zturb, v4, w4): - print("A") - print(yturb, zturb) # get data from fixtures xturb, _x, _y, _z, dx, dy, dz = grid_info yaw, tilt, Cp, Ct, Ctprime, an, u4, REWS = wake_model_args