pyffag 0.1.0__py3-none-any.whl

pyffag/__init__.py

@@ -0,0 +1,51 @@
+"""pyffag — DA-based FFAG accelerator tracking.
+
+Built on daceypy for arbitrary-order differential algebra arithmetic,
+pyffag provides transfer map computation through FFAG sector magnets
+via integration of the exact midplane Hamiltonian.
+
+Example
+-------
+>>> from daceypy import DA
+>>> from pyffag import sector_map, compose_n, tune
+>>> from pyffag.constants import kinetic_to_brho, M_PROTON
+>>>
+>>> DA.init(5, 2)
+>>> Brho = kinetic_to_brho(150.0, M_PROTON)
+>>> cell = sector_map([1.0], Brho, angle=0.5236)  # 30-degree uniform dipole
+>>> ring = compose_n(cell, 12)
+>>> print(f"Tune: {tune(ring):.4f}")
+"""
+
+from pyffag.sector import sector_map
+from pyffag.elements import (
+    drift_map,
+    drift_map_paraxial,
+    edge_kick,
+    thin_quad,
+    thin_sext,
+    thin_oct,
+)
+from pyffag.ring import compose, compose_sequence, compose_n, find_closed_orbit
+from pyffag.optics import transfer_matrix, tune, is_stable, twiss, symplecticity_error
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "sector_map",
+    "drift_map",
+    "drift_map_paraxial",
+    "edge_kick",
+    "thin_quad",
+    "thin_sext",
+    "thin_oct",
+    "compose",
+    "compose_sequence",
+    "compose_n",
+    "find_closed_orbit",
+    "transfer_matrix",
+    "tune",
+    "is_stable",
+    "twiss",
+    "symplecticity_error",
+]

pyffag/constants.py

@@ -0,0 +1,73 @@
+"""Physical constants for accelerator physics (SI + natural units)."""
+
+# Speed of light [m/s]
+C_LIGHT = 299792458.0
+
+# Proton mass [MeV/c^2]
+M_PROTON = 938.27208816
+
+# Electron mass [MeV/c^2]
+M_ELECTRON = 0.51099895069
+
+# Muon mass [MeV/c^2]
+M_MUON = 105.6583755
+
+# Elementary charge [C]
+E_CHARGE = 1.602176634e-19
+
+# Conversion: momentum [MeV/c] to magnetic rigidity [T·m]
+# Brho = p / (q * c) = p [eV/c] / (e * c) = p [MeV/c] * 1e6 / (c)
+# In convenient units: Brho [T·m] = p [MeV/c] / 299.792458
+BRHO_FACTOR = 1e6 / C_LIGHT  # multiply by p [MeV/c] to get Brho [T·m]
+
+
+def kinetic_to_momentum(T, mass):
+    """Convert kinetic energy to momentum.
+
+    Parameters
+    ----------
+    T : float
+        Kinetic energy [MeV].
+    mass : float
+        Rest mass [MeV/c^2].
+
+    Returns
+    -------
+    float
+        Momentum [MeV/c].
+    """
+    return (T * (T + 2 * mass)) ** 0.5
+
+
+def momentum_to_brho(p):
+    """Convert momentum to magnetic rigidity.
+
+    Parameters
+    ----------
+    p : float
+        Momentum [MeV/c].
+
+    Returns
+    -------
+    float
+        Magnetic rigidity Bρ [T·m].
+    """
+    return p * BRHO_FACTOR
+
+
+def kinetic_to_brho(T, mass):
+    """Convert kinetic energy to magnetic rigidity.
+
+    Parameters
+    ----------
+    T : float
+        Kinetic energy [MeV].
+    mass : float
+        Rest mass [MeV/c^2].
+
+    Returns
+    -------
+    float
+        Magnetic rigidity Bρ [T·m].
+    """
+    return momentum_to_brho(kinetic_to_momentum(T, mass))

pyffag/elements.py

@@ -0,0 +1,116 @@
+"""Standard beam-line elements as DA maps (midplane, 1 DOF)."""
+
+import numpy as np
+from daceypy import DA
+
+
+def drift_map(length):
+    """Exact drift-space map (no paraxial approximation).
+
+    Uses the exact expression x' = x + L * px / sqrt(1 - px^2).
+
+    Parameters
+    ----------
+    length : float
+        Drift length [m].
+
+    Returns
+    -------
+    list of DA
+        [x_out, px_out].
+    """
+    x, px = DA(1), DA(2)
+    ps = DA.sqrt(1.0 - px * px)
+    return [x + length * px / ps, px]
+
+
+def drift_map_paraxial(length):
+    """Paraxial drift-space map: x' = x + L*px.
+
+    Parameters
+    ----------
+    length : float
+        Drift length [m].
+
+    Returns
+    -------
+    list of DA
+        [x_out, px_out].
+    """
+    x, px = DA(1), DA(2)
+    return [x + length * px, px]
+
+
+def edge_kick(h, e1):
+    """Thin edge-focusing kick for a rectangular (non-sector) magnet.
+
+    At an edge tilted by angle e1 from the radial direction, the
+    horizontal kick is dpx = +h * tan(e1) * x.
+
+    For a sector magnet (radial edges), e1 = 0 and there is no kick.
+
+    Parameters
+    ----------
+    h : float
+        Reference curvature 1/rho [1/m].
+    e1 : float
+        Edge angle [rad].  Positive = edge rotated toward the magnet body.
+
+    Returns
+    -------
+    list of DA
+        [x_out, px_out].
+    """
+    x, px = DA(1), DA(2)
+    return [x, px + h * np.tan(e1) * x]
+
+
+def thin_quad(k1L):
+    """Thin quadrupole kick: dpx = -k1L * x.
+
+    Parameters
+    ----------
+    k1L : float
+        Integrated quadrupole strength [1/m].
+
+    Returns
+    -------
+    list of DA
+        [x_out, px_out].
+    """
+    x, px = DA(1), DA(2)
+    return [x, px - k1L * x]
+
+
+def thin_sext(k2L):
+    """Thin sextupole kick: dpx = -(k2L/2) * x^2.
+
+    Parameters
+    ----------
+    k2L : float
+        Integrated sextupole strength [1/m^2].
+
+    Returns
+    -------
+    list of DA
+        [x_out, px_out].
+    """
+    x, px = DA(1), DA(2)
+    return [x, px - (k2L / 2) * x ** 2]
+
+
+def thin_oct(k3L):
+    """Thin octupole kick: dpx = -(k3L/6) * x^3.
+
+    Parameters
+    ----------
+    k3L : float
+        Integrated octupole strength [1/m^3].
+
+    Returns
+    -------
+    list of DA
+        [x_out, px_out].
+    """
+    x, px = DA(1), DA(2)
+    return [x, px - (k3L / 6) * x ** 3]

pyffag/optics.py

@@ -0,0 +1,118 @@
+"""Linear optics extraction from DA transfer maps."""
+
+import numpy as np
+
+
+def transfer_matrix(da_map):
+    """Extract the 2x2 transfer matrix from a DA map.
+
+    Parameters
+    ----------
+    da_map : list of DA
+        [x', px'] map components.
+
+    Returns
+    -------
+    ndarray, shape (2, 2)
+        Transfer matrix M.
+    """
+    M = np.zeros((2, 2))
+    M[0, 0] = da_map[0].getCoefficient([1, 0])
+    M[0, 1] = da_map[0].getCoefficient([0, 1])
+    M[1, 0] = da_map[1].getCoefficient([1, 0])
+    M[1, 1] = da_map[1].getCoefficient([0, 1])
+    return M
+
+
+def tune(da_map):
+    """Extract the fractional tune from a DA map.
+
+    Parameters
+    ----------
+    da_map : list of DA
+        One-turn (or one-cell) [x', px'] map.
+
+    Returns
+    -------
+    float
+        Fractional tune nu in [0, 0.5].
+    """
+    M = transfer_matrix(da_map)
+    cos_mu = (M[0, 0] + M[1, 1]) / 2.0
+    cos_mu = np.clip(cos_mu, -1.0, 1.0)
+    return np.arccos(cos_mu) / (2.0 * np.pi)
+
+
+def is_stable(da_map):
+    """Check if the linear map is stable (|Tr M| < 2).
+
+    Parameters
+    ----------
+    da_map : list of DA
+        [x', px'] map.
+
+    Returns
+    -------
+    bool
+    """
+    M = transfer_matrix(da_map)
+    return abs(M[0, 0] + M[1, 1]) < 2.0
+
+
+def twiss(da_map):
+    """Extract Courant-Snyder (Twiss) parameters from a periodic map.
+
+    Assumes the map is one full period (cell or ring) and is stable.
+
+    Parameters
+    ----------
+    da_map : list of DA
+        One-period [x', px'] map.
+
+    Returns
+    -------
+    dict
+        {'beta': float, 'alpha': float, 'gamma': float, 'tune': float}
+        beta in [m], alpha dimensionless, gamma in [1/m].
+    """
+    M = transfer_matrix(da_map)
+    cos_mu = (M[0, 0] + M[1, 1]) / 2.0
+
+    if abs(cos_mu) >= 1.0:
+        raise ValueError(f"Unstable map: Tr/2 = {cos_mu:.6f}")
+
+    mu = np.arccos(np.clip(cos_mu, -1.0, 1.0))
+    sin_mu = np.sin(mu)
+
+    # Sign of sin(mu): from M12
+    if M[0, 1] < 0:
+        sin_mu = -sin_mu
+        mu = 2 * np.pi - mu
+
+    beta = M[0, 1] / sin_mu
+    alpha = (M[0, 0] - M[1, 1]) / (2.0 * sin_mu)
+    gamma = -M[1, 0] / sin_mu
+
+    return {
+        'beta': beta,
+        'alpha': alpha,
+        'gamma': gamma,
+        'tune': mu / (2.0 * np.pi),
+    }
+
+
+def symplecticity_error(da_map):
+    """Check how far the linear map is from symplectic (det M - 1).
+
+    Parameters
+    ----------
+    da_map : list of DA
+        [x', px'] map.
+
+    Returns
+    -------
+    float
+        |det(M) - 1|.
+    """
+    M = transfer_matrix(da_map)
+    return abs(np.linalg.det(M) - 1.0)

pyffag/ring.py

@@ -0,0 +1,173 @@
+"""Ring-level operations: map composition and closed-orbit finding."""
+
+import numpy as np
+from daceypy import DA
+
+
+def compose(map1, map2):
+    """Compose two maps: apply map1 first, then map2.
+
+    Parameters
+    ----------
+    map1, map2 : list of DA
+        Map components [x', px'].
+
+    Returns
+    -------
+    list of DA
+        Composed map components.
+    """
+    return [map2[i].eval(map1) for i in range(len(map1))]
+
+
+def compose_sequence(maps):
+    """Compose a sequence of maps in order (first element applied first).
+
+    Parameters
+    ----------
+    maps : list of list-of-DA
+        Each entry is [x', px'] for one element.
+
+    Returns
+    -------
+    list of DA
+        Full composed map.
+    """
+    result = maps[0]
+    for m in maps[1:]:
+        result = compose(result, m)
+    return result
+
+
+def compose_n(cell_map, n):
+    """Compose a cell map with itself n times (n-turn or n-cell map).
+
+    Parameters
+    ----------
+    cell_map : list of DA
+        One-cell map components.
+    n : int
+        Number of repetitions.
+
+    Returns
+    -------
+    list of DA
+        n-fold composed map.
+    """
+    result = cell_map
+    for _ in range(n - 1):
+        result = compose(result, cell_map)
+    return result
+
+
+def find_closed_orbit(ring_builder, x_guess=0.0, px_guess=0.0,
+                      tol=1e-12, max_iter=20):
+    """Find the closed orbit of a ring using Newton's method with DA.
+
+    At each iteration, the ring map is evaluated with DA to simultaneously
+    obtain the map value and Jacobian, enabling a Newton update.
+
+    Parameters
+    ----------
+    ring_builder : callable
+        A function that takes no arguments, constructs the full ring DA map
+        (at the current DA.init settings), and returns [x_out, px_out].
+        The map should be built with DA(1) and DA(2) as initial conditions
+        offset from the current guess — the caller handles this by building
+        the map fresh each iteration.
+    x_guess, px_guess : float
+        Initial guess for the closed orbit position and angle.
+    tol : float
+        Convergence tolerance on |x_final - x_initial|.
+    max_iter : int
+        Maximum Newton iterations.
+
+    Returns
+    -------
+    x_co, px_co : float
+        Closed orbit position [m] and angle [rad].
+    converged : bool
+        Whether the iteration converged within tolerance.
+    """
+    x_co, px_co = x_guess, px_guess
+
+    for iteration in range(max_iter):
+        # Build and evaluate the ring map around current guess
+        ring_map = ring_builder()
+
+        # Extract the fixed-point residual: M(x_co) - x_co
+        # DA(1) and DA(2) represent deviations from origin, but the
+        # ring_builder should construct the map with initial conditions
+        # at the guess.  The constant part of the output is the image
+        # of (x_co, px_co), and we need it to equal (x_co, px_co).
+        x_out_0 = ring_map[0].getCoefficient([0, 0])
+        px_out_0 = ring_map[1].getCoefficient([0, 0])
+
+        res_x = x_out_0 - x_co
+        res_px = px_out_0 - px_co
+
+        if abs(res_x) < tol and abs(res_px) < tol:
+            return x_co, px_co, True
+
+        # Jacobian from linear DA terms
+        J11 = ring_map[0].getCoefficient([1, 0])
+        J12 = ring_map[0].getCoefficient([0, 1])
+        J21 = ring_map[1].getCoefficient([1, 0])
+        J22 = ring_map[1].getCoefficient([0, 1])
+
+        # Newton: (I - J) dx = residual
+        A = np.array([[1 - J11, -J12], [-J21, 1 - J22]])
+        b = np.array([res_x, res_px])
+        dx = np.linalg.solve(A, b)
+
+        x_co -= dx[0]
+        px_co -= dx[1]
+
+    return x_co, px_co, False
+
+
+def find_closed_orbit_simple(ring_func, x_guess=0.0, tol=1e-12, max_iter=20):
+    """Find closed orbit for a ring function that takes (x0, px0) floats.
+
+    Simpler interface: the ring function evaluates a scalar one-turn map
+    using DA internally and returns (x_final, px_final, J11, J12, J21, J22).
+
+    For most cases, use the pattern below instead::
+
+        DA.init(order, 2)
+        ring_map = build_ring_map(x_co_guess)  # shifts DA origin
+        # extract residual and Jacobian from ring_map
+
+    Parameters
+    ----------
+    ring_func : callable
+        Takes (x0: float, px0: float) and returns a dict with keys
+        'x', 'px' (floats, final coords) and 'J' (2x2 ndarray, Jacobian).
+    x_guess : float
+        Initial guess for closed orbit radius deviation.
+    tol : float
+        Convergence tolerance.
+    max_iter : int
+        Maximum iterations.
+
+    Returns
+    -------
+    x_co : float
+        Closed orbit position.
+    converged : bool
+        Whether converged.
+    """
+    x_co = x_guess
+    px_co = 0.0
+
+    for _ in range(max_iter):
+        result = ring_func(x_co, px_co)
+        res = np.array([result['x'] - x_co, result['px'] - px_co])
+        if np.max(np.abs(res)) < tol:
+            return x_co, True
+        A = np.eye(2) - result['J']
+        dx = np.linalg.solve(A, res)
+        x_co -= dx[0]
+        px_co -= dx[1]
+
+    return x_co, False

pyffag/sector.py

@@ -0,0 +1,99 @@
+"""DA tracking through FFAG sector magnets.
+
+Integrates the exact midplane Hamiltonian in Frenet-Serret (curvilinear)
+coordinates with arc length s as the independent variable.  The equations
+of motion are derived from the generating Hamiltonian
+
+    K = -(1+hx) sqrt(p^2 - px^2) + h(1+hx/2)x * p
+
+where h = 1/rho is the reference curvature and p = |p|/p0 is the scaled
+total momentum (1 for on-momentum).  For a pure magnetic sector with
+By(x) = B0 + B1*x + B2*x^2 + ..., the resulting ODEs are:
+
+    dx/ds  = (1 + hx) * px / sqrt(1 - px^2)
+    dpx/ds = h * sqrt(1 - px^2) - (1 + hx) * By(x) / Brho
+
+For sector magnets, the edge faces are radial — no edge focusing.
+"""
+
+import numpy as np
+from daceypy import DA, array, integrator
+from daceypy.RK import RK78
+
+
+class _SectorIntegrator(integrator):
+    """RK7(8) integrator for a sector magnet with polynomial field."""
+
+    # Set by sector_map() before propagation
+    _h = 0.0         # curvature 1/rho [1/m]
+    _B_coeffs = []    # [B0, B1, B2, ...] where By(x) = sum(Bn * x^n)
+    _inv_Brho = 0.0   # 1/(Brho) [1/(T·m)]
+
+    @staticmethod
+    def f(z, s):
+        x, px = z[0], z[1]
+        h = _SectorIntegrator._h
+        inv_Brho = _SectorIntegrator._inv_Brho
+        B_coeffs = _SectorIntegrator._B_coeffs
+
+        # By(x) = B0 + B1*x + B2*x^2 + ...
+        By = DA(B_coeffs[0]) if isinstance(B_coeffs[0], (int, float)) else B_coeffs[0]
+        xn = DA(1.0)  # x^0 = 1
+        for n in range(1, len(B_coeffs)):
+            xn = xn * x
+            By = By + B_coeffs[n] * xn
+
+        ohx = 1.0 + h * x  # (1 + h*x)
+        ps = DA.sqrt(1.0 - px * px)  # sqrt(1 - px^2)
+
+        dxds = ohx * px / ps
+        dpxds = h * ps - ohx * By * inv_Brho
+
+        return array([dxds, dpxds])
+
+
+def sector_map(B_coeffs, Brho, angle, rho=None, rtol=1e-14, atol=1e-14):
+    """Compute the DA transfer map through a magnetic sector magnet.
+
+    Integrates the exact midplane Hamiltonian (no paraxial approximation)
+    through a sector magnet with radial edge faces.
+
+    Parameters
+    ----------
+    B_coeffs : list of float
+        Midplane field polynomial coefficients.
+        By(x) = B_coeffs[0] + B_coeffs[1]*x + B_coeffs[2]*x^2 + ...
+        Units: B_coeffs[0] in [T], B_coeffs[1] in [T/m], etc.
+    Brho : float
+        Magnetic rigidity p/q [T·m].
+    angle : float
+        Bending angle of the sector [rad].  The sign of angle should match
+        the sign of B_coeffs[0]: positive angle for positive B0.
+    rho : float, optional
+        Reference bending radius [m].  Default: |Brho / B_coeffs[0]|.
+    rtol, atol : float
+        Relative and absolute tolerance for the RK7(8) integrator.
+
+    Returns
+    -------
+    list of DA
+        [x_out, px_out] — the DA transfer map components.
+    """
+    B0 = B_coeffs[0]
+    if rho is None:
+        rho = abs(Brho / B0)
+    arc_length = rho * abs(angle)
+
+    _SectorIntegrator._h = 1.0 / rho * np.sign(B0)
+    _SectorIntegrator._B_coeffs = B_coeffs
+    _SectorIntegrator._inv_Brho = 1.0 / Brho
+
+    prop = _SectorIntegrator(RKcoeff=RK78(), stateType=array)
+    prop.loadTime(0.0, arc_length)
+    prop.loadTol(rtol, atol)
+    prop.loadStepSize()
+
+    z0 = array([DA(1), DA(2)])
+    zf = prop.propagate(z0, 0.0, arc_length)
+
+    return [zf[0], zf[1]]

pyffag-0.1.0.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: pyffag
+Version: 0.1.0
+Summary: DA-based FFAG accelerator tracking using differential algebra
+Author-email: Eremey Valetov <evv@msu.edu>
+License: MIT
+Project-URL: Repository, https://github.com/evvaletov/pyffag
+Keywords: FFAG,accelerator,beam physics,differential algebra,transfer map
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: daceypy>=1.3.0
+Requires-Dist: numpy>=1.24
+Dynamic: license-file
+
+# pyffag
+
+DA-based FFAG accelerator tracking using differential algebra.
+
+Built on [daceypy](https://pypi.org/project/daceypy/) for arbitrary-order
+transfer map computation through FFAG sector magnets via integration of the
+exact midplane Hamiltonian.
+
+## Installation
+
+```bash
+pip install pyffag
+```
+
+## Quick start
+
+```python
+import numpy as np
+from daceypy import DA
+from pyffag import sector_map, compose_sequence, compose_n, tune, twiss
+from pyffag.constants import kinetic_to_brho, M_PROTON
+
+# 150 MeV proton FFAG ring: 12 FDF-triplet cells
+DA.init(7, 2)  # DA order 7, 2 variables (x, px)
+Brho = kinetic_to_brho(150.0, M_PROTON)  # magnetic rigidity [T·m]
+
+# F magnet: B(x) = 1.2 + 3.0*x + 4.0*x² [T], 12° sector
+F = sector_map([1.2, 3.0, 4.0], Brho, angle=np.radians(12.0))
+
+# D magnet: B(x) = 1.2 − 5.0*x − 5.0*x² [T], 6° sector
+D = sector_map([1.2, -5.0, -5.0], Brho, angle=np.radians(6.0))
+
+# One cell = F + D + F, full ring = 12 cells
+cell = compose_sequence([F, D, F])
+ring = compose_n(cell, 12)
+
+print(f"Cell tune: {twiss(cell)['tune']:.4f}")
+print(f"Ring tune: {tune(ring):.4f}")
+```
+
+## Features
+
+- **Sector magnet tracking**: Exact midplane Hamiltonian integration
+  (no paraxial approximation) through sector magnets with polynomial
+  field profiles B(x) = B₀ + B₁x + B₂x² + ...
+- **Element maps**: Drift (exact), thin quadrupole, sextupole, octupole,
+  edge kicks for rectangular magnets
+- **Ring operations**: Map composition, N-fold composition, closed orbit
+  finding via Newton's method with DA Jacobian
+- **Optics**: Tune, Twiss parameters, stability check, symplecticity error
+
+## Physics
+
+The core `sector_map()` integrates the equations of motion in Frenet-Serret
+(curvilinear) coordinates with arc length as the independent variable:
+
+```
+dx/ds  = (1 + hx) · px / √(1 − px²)
+dpx/ds = h · √(1 − px²) − (1 + hx) · By(x) / (Bρ)
+```
+
+where h = 1/ρ is the reference curvature.  Sector magnets have radial edge
+faces (no edge focusing).  The exact sqrt formulation captures kinematic
+nonlinearities that the paraxial approximation misses.
+
+## Integration with danf
+
+Use with [danf](https://pypi.org/project/danf/) for nonlinear normal form
+analysis (amplitude-dependent tune shifts, resonance driving terms):
+
+```python
+from danf import NormalForm
+
+nf = NormalForm(ring)
+nf.compute()
+print(f"ADTS: dν/dε = {nf.detuning['dnux_dJx'] / 2:.4f}")
+```
+
+## License
+
+MIT

pyffag-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyffag/__init__.py,sha256=8gcUrfJ4gLX3WvLYBaTMaS0TK_MVOnMjAtDC3omKPzk,1284
+pyffag/constants.py,sha256=WC62B9hZwieCHxMBCYgmth9ipUwXfIlVjtqNcabT-8Y,1478
+pyffag/elements.py,sha256=O4EetmmFjWQi9hu2Y4dmOhGE_TPCnEPWvqRQ9sImQ08,2271
+pyffag/optics.py,sha256=BjbRQq75HqpOmO-3b9Q_yXZVvI7RYXYEhFIOAZNtJSY,2554
+pyffag/ring.py,sha256=e1rD1Y_5dETwYx6VfWYL8AP7-QHgauydsX7O7yZj2RI,5002
+pyffag/sector.py,sha256=yMck_n4LDqPEMH8EkAnMMbUOLpMo3mYBBppOYBdamWo,3257
+pyffag-0.1.0.dist-info/licenses/LICENSE,sha256=-mIPUvK6wSxeUkO82LHW_GbhCgP23AFZPoTJyS8AMY0,1071
+pyffag-0.1.0.dist-info/METADATA,sha256=oj1kRhU5RbWasRXqYfy0jLVGydAT9-n8P2ATwD7WKUk,3146
+pyffag-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyffag-0.1.0.dist-info/top_level.txt,sha256=NHPXwUwaY_0GvErPdmP5OBsZkvZ6y5-x_NGjWNxCEwU,7
+pyffag-0.1.0.dist-info/RECORD,,

pyffag-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyffag-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eremey Valetov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyffag-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyffag